Begin updating packaging for Abseil 20210324

Bump package versions and names to reflect the new Abseil LTS. Remove
patches that have been incorporated upstream, and refresh other
patches.

19 files changed, 93 insertions, 1389 deletions

diff --git a/debian/changelog b/debian/changelog
index c821ca3c..e48b1b5d 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,10 +1,11 @@
-abseil (0~20200923.3-4) UNRELEASED; urgency=medium
+abseil (0~20210324.0-1) UNRELEASED; urgency=medium
 
+  * New upstream release.
   * Correct debian/watch search URLs to avoid picking up rc versions.
   * Mangle upstream version in debian/watch to match manual mangling in
     debian/changelog.
 
- -- Benjamin Barenblat <bbaren@debian.org>  Thu, 08 Apr 2021 10:14:59 -0400
+ -- Benjamin Barenblat <bbaren@debian.org>  Thu, 08 Apr 2021 10:28:01 -0400
 
 abseil (0~20200923.3-3) unstable; urgency=medium
 
diff --git a/debian/control b/debian/control
index ea2a5fd3..7c552426 100644
--- a/debian/control
+++ b/debian/control
@@ -37,7 +37,7 @@ Architecture: any
 Multi-Arch: same
 Section: libdevel
 Depends:
- libabsl20200923 (= ${binary:Version}),
+ libabsl20210324 (= ${binary:Version}),
  ${misc:Depends},
 Recommends: cmake (>= 2.6), g++ (>= 4.7)
 Description: ${source:Synopsis} (development files)
@@ -46,7 +46,7 @@ Description: ${source:Synopsis} (development files)
  This package contains header files and other data necessary for developing with
  Abseil.
 
-Package: libabsl20200923
+Package: libabsl20210324
 Architecture: any
 Multi-Arch: same
 Depends: ${shlibs:Depends}, ${misc:Depends}
diff --git a/debian/copyright b/debian/copyright
index 78336c12..986a4261 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -8,17 +8,13 @@ License: Apache-2.0
 Files: *
 Copyright:
  2000-2017 Google Inc.
- 2017-2020 The Abseil Authors
+ 2017-2021 The Abseil Authors
 License: Apache-2.0
 
 Files: debian/*
 Copyright: 2020 Google LLC
 License: Apache-2.0
 
-Files: debian/patches/fix-hppa.diff
-Copyright: 2020 John David Anglin <dave.anglin@bell.net>
-License: Apache-2.0
-
 License: Apache-2.0
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
diff --git a/debian/gbp.conf b/debian/gbp.conf
index c24fe094..aa383957 100644
--- a/debian/gbp.conf
+++ b/debian/gbp.conf
@@ -13,4 +13,4 @@
 # the License.
 
 [DEFAULT]
-upstream-tag = 20200923.3
+upstream-tag = 20210324.0
diff --git a/debian/libabsl20200923.shlibs b/debian/libabsl20200923.shlibs
deleted file mode 100644
index e84201fb..00000000
--- a/debian/libabsl20200923.shlibs
+++ /dev/null
@@ -1,74 +0,0 @@
-# Copyright 2020 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not
-# use this file except in compliance with the License. You may obtain a copy of
-# the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations under
-# the License.
-#
-libabsl_bad_any_cast_impl 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_bad_optional_access 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_bad_variant_access 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_base 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_city 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_civil_time 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_cord 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_debugging_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_demangle_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_examine_stack 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_exponential_biased 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_failure_signal_handler 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_commandlineflag 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_commandlineflag_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_config 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_marshalling 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_parse 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_private_handle_accessor 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_program_name 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_reflection 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_usage 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_flags_usage_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_graphcycles_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_hash 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_hashtablez_sampler 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_int128 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_leak_check 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_leak_check_disable 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_log_severity 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_malloc_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_periodic_sampler 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_distributions 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_distribution_test_util 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_platform 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_pool_urbg 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_randen 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_randen_hwaes 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_randen_hwaes_impl 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_randen_slow 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_internal_seed_material 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_seed_gen_exception 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_random_seed_sequences 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_raw_hash_set 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_raw_logging_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_scoped_set_env 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_spinlock_wait 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_stacktrace 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_status 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_statusor 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_str_format_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_strerror 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_strings 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_strings_internal 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_symbolize 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_synchronization 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_throw_delegate 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_time 20200923 libabsl20200923 (>= 0~20200923-1)
-libabsl_time_zone 20200923 libabsl20200923 (>= 0~20200923-1)
diff --git a/debian/libabsl20200923.install b/debian/libabsl20210324.install
index e5967b9d..e5967b9d 100644
--- a/debian/libabsl20200923.install
+++ b/debian/libabsl20210324.install
diff --git a/debian/libabsl20200923.lintian-overrides b/debian/libabsl20210324.lintian-overrides
index 1fed50f7..090227b0 100644
--- a/debian/libabsl20200923.lintian-overrides
+++ b/debian/libabsl20210324.lintian-overrides
@@ -12,6 +12,6 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-libabsl20200923: no-symbols-control-file usr/lib/*/libabsl_*
-libabsl20200923: package-name-doesnt-match-sonames libabsl-*
-libabsl20200923: spelling-error-in-binary usr/lib/*/libabsl_flags_usage_internal.so* helpfull helpful
+libabsl20210324: no-symbols-control-file usr/lib/*/libabsl_*
+libabsl20210324: package-name-doesnt-match-sonames libabsl-*
+libabsl20210324: spelling-error-in-binary usr/lib/*/libabsl_flags_usage_internal.so* helpfull helpful
diff --git a/debian/libabsl20210324.shlibs b/debian/libabsl20210324.shlibs
new file mode 100644
index 00000000..4f30c3d0
--- /dev/null
+++ b/debian/libabsl20210324.shlibs
@@ -0,0 +1,74 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+#
+libabsl_bad_any_cast_impl 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_bad_optional_access 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_bad_variant_access 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_base 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_city 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_civil_time 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_cord 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_debugging_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_demangle_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_examine_stack 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_exponential_biased 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_failure_signal_handler 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_commandlineflag 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_commandlineflag_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_config 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_marshalling 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_parse 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_private_handle_accessor 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_program_name 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_reflection 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_usage 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_flags_usage_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_graphcycles_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_hash 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_hashtablez_sampler 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_int128 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_leak_check 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_leak_check_disable 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_log_severity 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_malloc_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_periodic_sampler 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_distributions 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_distribution_test_util 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_platform 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_pool_urbg 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_randen 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_randen_hwaes 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_randen_hwaes_impl 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_randen_slow 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_internal_seed_material 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_seed_gen_exception 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_random_seed_sequences 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_raw_hash_set 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_raw_logging_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_scoped_set_env 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_spinlock_wait 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_stacktrace 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_status 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_statusor 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_str_format_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_strerror 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_strings 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_strings_internal 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_symbolize 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_synchronization 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_throw_delegate 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_time 20210324 libabsl20210324 (>= 0~20210324.0-1)
+libabsl_time_zone 20210324 libabsl20210324 (>= 0~20210324.0-1)
diff --git a/debian/patches/configure.diff b/debian/patches/configure.diff
index 5c47b152..786994b0 100644
--- a/debian/patches/configure.diff
+++ b/debian/patches/configure.diff
@@ -22,16 +22,16 @@ Configure Abseil for Debian.
 
 --- a/CMake/AbseilHelpers.cmake
 +++ b/CMake/AbseilHelpers.cmake
-@@ -217,6 +217,9 @@
+@@ -263,7 +263,8 @@
+     if(ABSL_ENABLE_INSTALL)
+       set_target_properties(${_NAME} PROPERTIES
          OUTPUT_NAME "absl_${_NAME}"
+-        SOVERSION "2103.0.0"
++        SOVERSION 20210324
++        VERSION "20210324.0.0"
        )
      endif()
-+
-+    set_property(TARGET ${_NAME} PROPERTY SOVERSION 20200923)
-+    set_property(TARGET ${_NAME} PROPERTY VERSION "20200923.0.1")
    else()
-     # Generating header-only library
-     add_library(${_NAME} INTERFACE)
 --- a/absl/base/options.h
 +++ b/absl/base/options.h
 @@ -100,7 +100,7 @@
@@ -74,8 +74,8 @@ Configure Abseil for Debian.
  // allowed.
  
  #define ABSL_OPTION_USE_INLINE_NAMESPACE 1
--#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_2020_09_23
-+#define ABSL_OPTION_INLINE_NAMESPACE_NAME debian1
+-#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20210324
++#define ABSL_OPTION_INLINE_NAMESPACE_NAME debian2
  
  // ABSL_OPTION_HARDENED
  //
diff --git a/debian/patches/cpu-frequency.diff b/debian/patches/cpu-frequency.diff
deleted file mode 100644
index adfba7e0..00000000
--- a/debian/patches/cpu-frequency.diff
+++ /dev/null
@@ -1,54 +0,0 @@
-From: Benjamin Barenblat <bbaren@google.com>
-Subject: Ignore missing CPU frequency on more architectures
-Forwarded: yes
-Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/1918ad2ae38aa32c74b558b322479a8efdd76363
-
-Linux on MIPS, PA-RISC, RISC-V, and SystemZ doesn’t expose the nominal CPU
-frequency via /sys, so don’t worry if `NominalCPUFrequency` returns 1.0 on those
-platforms.
-
-Some POWER machines expose the CPU frequency; others do not. Since we can’t
-predict which type of machine the tests will run on, simply disable testing for
-`NominalCPUFrequency` on POWER.
-
-The author works at Google. Upstream applied this patch as Piper revision
-347079873 and exported it to GitHub; the Applied-Upstream URL above points to
-the exported commit.
-
---- a/absl/base/internal/sysinfo_test.cc
-+++ b/absl/base/internal/sysinfo_test.cc
-@@ -37,17 +37,28 @@ TEST(SysinfoTest, NumCPUs) {
-       << "NumCPUs() should not have the default value of 0";
- }
- 
-+// Ensure that NominalCPUFrequency returns a reasonable value, or 1.00 on
-+// platforms where the CPU frequency is not available through sysfs.
-+//
-+// POWER is particularly problematic here; some Linux kernels expose the CPU
-+// frequency, while others do not. Since we can't predict a priori what a given
-+// machine is going to do, just disable this test on POWER on Linux.
-+#if !(defined(__linux) && (defined(__ppc64__) || defined(__PPC64__)))
- TEST(SysinfoTest, NominalCPUFrequency) {
--#if !(defined(__aarch64__) && defined(__linux__)) && !defined(__EMSCRIPTEN__)
--  EXPECT_GE(NominalCPUFrequency(), 1000.0)
--      << "NominalCPUFrequency() did not return a reasonable value";
--#else
--  // Aarch64 cannot read the CPU frequency from sysfs, so we get back 1.0.
--  // Emscripten does not have a sysfs to read from at all.
-+  // Linux only exposes the CPU frequency on certain architectures, and
-+  // Emscripten doesn't expose it at all.
-+#if defined(__linux__) &&                                                  \
-+        (defined(__aarch64__) || defined(__hppa__) || defined(__mips__) || \
-+         defined(__riscv) || defined(__s390x__)) ||                        \
-+    defined(__EMSCRIPTEN__)
-   EXPECT_EQ(NominalCPUFrequency(), 1.0)
-       << "CPU frequency detection was fixed! Please update unittest.";
-+#else
-+  EXPECT_GE(NominalCPUFrequency(), 1000.0)
-+      << "NominalCPUFrequency() did not return a reasonable value";
- #endif
- }
-+#endif
- 
- TEST(SysinfoTest, GetTID) {
-   EXPECT_EQ(GetTID(), GetTID());  // Basic compile and equality test.
diff --git a/debian/patches/disable-double-double-tests.diff b/debian/patches/disable-double-double-tests.diff
deleted file mode 100644
index e80a8a78..00000000
--- a/debian/patches/disable-double-double-tests.diff
+++ /dev/null
@@ -1,489 +0,0 @@
-From: Benjamin Barenblat <bbaren@google.com>
-Subject: Stop testing with double-double random variables
-Forwarded: yes
-Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/ab21820d47e4f83875dda008b600514d3520fd35
-
-On POWER, long double is often represented as a pair of doubles added
-together (double-double arithmetic). We’ve already special-cased
-double-double arithmetic in a number of tests, but compiler
-bugs [1, 2, 3] have now triggered both false positives and false
-negatives, which suggests testing with double doubles is unlikely to
-yield useful signal. Remove the special casing and detect if we’re on a
-double-double system; if so, just don’t test long doubles.
-
-[1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99048
-[2] https://bugs.llvm.org/show_bug.cgi?id=49131
-[3] https://bugs.llvm.org/show_bug.cgi?id=49132
-
-The author works at Google. Upstream applied this patch as Piper
-revision 360793161 and exported it to GitHub; the the Applied-Upstream
-URL above points to the exported commit.
-
---- a/CMake/AbseilDll.cmake
-+++ b/CMake/AbseilDll.cmake
-@@ -126,6 +126,7 @@ set(ABSL_INTERNAL_DLL_FILES
-   "meta/type_traits.h"
-   "numeric/int128.cc"
-   "numeric/int128.h"
-+  "numeric/internal/representation.h"
-   "random/bernoulli_distribution.h"
-   "random/beta_distribution.h"
-   "random/bit_gen_ref.h"
---- a/absl/numeric/BUILD.bazel
-+++ b/absl/numeric/BUILD.bazel
-@@ -72,3 +72,15 @@
-         "@com_github_google_benchmark//:benchmark_main",
-     ],
- )
-+
-+cc_library(
-+    name = "representation",
-+    hdrs = [
-+        "internal/representation.h",
-+    ],
-+    copts = ABSL_DEFAULT_COPTS,
-+    linkopts = ABSL_DEFAULT_LINKOPTS,
-+    deps = [
-+        "//absl/base:config",
-+    ],
-+)
---- a/absl/numeric/CMakeLists.txt
-+++ b/absl/numeric/CMakeLists.txt
-@@ -59,3 +59,15 @@
-     absl::int128
-   PUBLIC
- )
-+
-+absl_cc_library(
-+  NAME
-+    numeric_representation
-+  HDRS
-+    "internal/representation.h"
-+  COPTS
-+    ${ABSL_DEFAULT_COPTS}
-+  DEPS
-+    absl::config
-+  PUBLIC
-+)
---- /dev/null
-+++ b/absl/numeric/internal/representation.h
-@@ -0,0 +1,55 @@
-+// Copyright 2021 The Abseil Authors
-+//
-+// Licensed under the Apache License, Version 2.0 (the "License");
-+// you may not use this file except in compliance with the License.
-+// You may obtain a copy of the License at
-+//
-+//     https://www.apache.org/licenses/LICENSE-2.0
-+//
-+// Unless required by applicable law or agreed to in writing, software
-+// distributed under the License is distributed on an "AS IS" BASIS,
-+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-+// See the License for the specific language governing permissions and
-+// limitations under the License.
-+
-+#ifndef ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
-+#define ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
-+
-+#include <limits>
-+
-+#include "absl/base/config.h"
-+
-+namespace absl {
-+ABSL_NAMESPACE_BEGIN
-+namespace numeric_internal {
-+
-+// Returns true iff long double is represented as a pair of doubles added
-+// together.
-+inline constexpr bool IsDoubleDouble() {
-+  // A double-double value always has exactly twice the precision of a double
-+  // value--one double carries the high digits and one double carries the low
-+  // digits. This property is not shared with any other common floating-point
-+  // representation, so this test won't trigger false positives. For reference,
-+  // this table gives the number of bits of precision of each common
-+  // floating-point representation:
-+  //
-+  //                type     precision
-+  //         IEEE single          24 b
-+  //         IEEE double          53
-+  //     x86 long double          64
-+  //       double-double         106
-+  //      IEEE quadruple         113
-+  //
-+  // Note in particular that a quadruple-precision float has greater precision
-+  // than a double-double float despite taking up the same amount of memory; the
-+  // quad has more of its bits allocated to the mantissa than the double-double
-+  // has.
-+  return std::numeric_limits<long double>::digits ==
-+         2 * std::numeric_limits<double>::digits;
-+}
-+
-+}  // namespace numeric_internal
-+ABSL_NAMESPACE_END
-+}  // namespace absl
-+
-+#endif  // ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
---- a/absl/random/BUILD.bazel
-+++ b/absl/random/BUILD.bazel
-@@ -187,6 +187,7 @@ cc_test(name = "beta_distribution_test",
-         ":distributions",
-         ":random",
-         "//absl/base:raw_logging_internal",
-+        "//absl/numeric:representation",
-         "//absl/random/internal:distribution_test_util",
-         "//absl/random/internal:pcg_engine",
-         "//absl/random/internal:sequence_urbg",
-@@ -307,6 +308,7 @@ cc_test(name = "exponential_distribution_test",
-         ":random",
-         "//absl/base:core_headers",
-         "//absl/base:raw_logging_internal",
-+        "//absl/numeric:representation",
-         "//absl/random/internal:distribution_test_util",
-         "//absl/random/internal:pcg_engine",
-         "//absl/random/internal:sequence_urbg",
-@@ -330,6 +332,7 @@ cc_test(name = "gaussian_distribution_test",
-         ":random",
-         "//absl/base:core_headers",
-         "//absl/base:raw_logging_internal",
-+        "//absl/numeric:representation",
-         "//absl/random/internal:distribution_test_util",
-         "//absl/random/internal:sequence_urbg",
-         "//absl/strings",
-@@ -376,6 +379,7 @@ cc_test(name = "uniform_real_distribution_test",
-         ":distributions",
-         ":random",
-         "//absl/base:raw_logging_internal",
-+        "//absl/numeric:representation",
-         "//absl/random/internal:distribution_test_util",
-         "//absl/random/internal:pcg_engine",
-         "//absl/random/internal:sequence_urbg",
---- a/absl/random/CMakeLists.txt
-+++ b/absl/random/CMakeLists.txt
-@@ -259,6 +259,7 @@ absl_cc_test(NAME random_beta_distribution_test
-   LINKOPTS
-     ${ABSL_DEFAULT_LINKOPTS}
-   DEPS
-+    absl::numeric_representation
-     absl::random_distributions
-     absl::random_random
-     absl::random_internal_distribution_test_util
-@@ -381,6 +382,7 @@ absl_cc_test(NAME random_exponential_distribution_test
-     ${ABSL_DEFAULT_LINKOPTS}
-   DEPS
-     absl::core_headers
-+    absl::numeric_representation
-     absl::random_distributions
-     absl::random_internal_distribution_test_util
-     absl::random_internal_pcg_engine
-@@ -404,6 +406,7 @@ absl_cc_test(NAME random_gaussian_distribution_test
-     ${ABSL_DEFAULT_LINKOPTS}
-   DEPS
-     absl::core_headers
-+    absl::numeric_representation
-     absl::random_distributions
-     absl::random_internal_distribution_test_util
-     absl::random_internal_sequence_urbg
-@@ -446,6 +449,7 @@ absl_cc_test(NAME random_uniform_real_distribution_test
-   LINKOPTS
-     ${ABSL_DEFAULT_LINKOPTS}
-   DEPS
-+    absl::numeric_representation
-     absl::random_distributions
-     absl::random_internal_distribution_test_util
-     absl::random_internal_pcg_engine
---- a/absl/random/beta_distribution_test.cc
-+++ b/absl/random/beta_distribution_test.cc
-@@ -21,12 +21,14 @@
- #include <random>
- #include <sstream>
- #include <string>
-+#include <type_traits>
- #include <unordered_map>
- #include <vector>
- 
- #include "gmock/gmock.h"
- #include "gtest/gtest.h"
- #include "absl/base/internal/raw_logging.h"
-+#include "absl/numeric/internal/representation.h"
- #include "absl/random/internal/chi_square.h"
- #include "absl/random/internal/distribution_test_util.h"
- #include "absl/random/internal/pcg_engine.h"
-@@ -42,7 +44,15 @@
- template <typename IntType>
- class BetaDistributionInterfaceTest : public ::testing::Test {};
- 
--using RealTypes = ::testing::Types<float, double, long double>;
-+// double-double arithmetic is not supported well by either GCC or Clang; see
-+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99048,
-+// https://bugs.llvm.org/show_bug.cgi?id=49131, and
-+// https://bugs.llvm.org/show_bug.cgi?id=49132. Don't bother running these tests
-+// with double doubles until compiler support is better.
-+using RealTypes =
-+    std::conditional<absl::numeric_internal::IsDoubleDouble(),
-+                     ::testing::Types<float, double>,
-+                     ::testing::Types<float, double, long double>>::type;
- TYPED_TEST_CASE(BetaDistributionInterfaceTest, RealTypes);
- 
- TYPED_TEST(BetaDistributionInterfaceTest, SerializeTest) {
-@@ -53,9 +63,6 @@ TYPED_TEST(BetaDistributionInterfaceTest, SerializeTest {
-   const TypeParam kLargeA =
-       std::exp(std::log((std::numeric_limits<TypeParam>::max)()) -
-                std::log(std::log((std::numeric_limits<TypeParam>::max)())));
--  const TypeParam kLargeAPPC = std::exp(
--      std::log((std::numeric_limits<TypeParam>::max)()) -
--      std::log(std::log((std::numeric_limits<TypeParam>::max)())) - 10.0f);
-   using param_type = typename absl::beta_distribution<TypeParam>::param_type;
- 
-   constexpr int kCount = 1000;
-@@ -76,9 +83,6 @@ TYPED_TEST(BetaDistributionInterfaceTest, SerializeTest {
-       kLargeA,                                //
-       std::nextafter(kLargeA, TypeParam(0)),  //
-       std::nextafter(kLargeA, std::numeric_limits<TypeParam>::max()),
--      kLargeAPPC,  //
--      std::nextafter(kLargeAPPC, TypeParam(0)),
--      std::nextafter(kLargeAPPC, std::numeric_limits<TypeParam>::max()),
-       // Boundary cases.
-       std::numeric_limits<TypeParam>::max(),
-       std::numeric_limits<TypeParam>::epsilon(),
-@@ -125,28 +129,6 @@ TYPED_TEST(BetaDistributionInterfaceTest, SerializeTest {
- 
-       ss >> after;
- 
--#if defined(__powerpc64__) || defined(__PPC64__) || defined(__powerpc__) || \
--    defined(__ppc__) || defined(__PPC__)
--      if (std::is_same<TypeParam, long double>::value) {
--        // Roundtripping floating point values requires sufficient precision
--        // to reconstruct the exact value. It turns out that long double
--        // has some errors doing this on ppc.
--        if (alpha <= std::numeric_limits<double>::max() &&
--            alpha >= std::numeric_limits<double>::lowest()) {
--          EXPECT_EQ(static_cast<double>(before.alpha()),
--                    static_cast<double>(after.alpha()))
--              << ss.str();
--        }
--        if (beta <= std::numeric_limits<double>::max() &&
--            beta >= std::numeric_limits<double>::lowest()) {
--          EXPECT_EQ(static_cast<double>(before.beta()),
--                    static_cast<double>(after.beta()))
--              << ss.str();
--        }
--        continue;
--      }
--#endif
--
-       EXPECT_EQ(before.alpha(), after.alpha());
-       EXPECT_EQ(before.beta(), after.beta());
-       EXPECT_EQ(before, after)           //
---- a/absl/random/exponential_distribution_test.cc
-+++ b/absl/random/exponential_distribution_test.cc
-@@ -30,6 +30,7 @@
- #include "gtest/gtest.h"
- #include "absl/base/internal/raw_logging.h"
- #include "absl/base/macros.h"
-+#include "absl/numeric/internal/representation.h"
- #include "absl/random/internal/chi_square.h"
- #include "absl/random/internal/distribution_test_util.h"
- #include "absl/random/internal/pcg_engine.h"
-@@ -50,7 +51,15 @@
- #if defined(__EMSCRIPTEN__)
- using RealTypes = ::testing::Types<float, double>;
- #else
--using RealTypes = ::testing::Types<float, double, long double>;
-+// double-double arithmetic is not supported well by either GCC or Clang; see
-+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99048,
-+// https://bugs.llvm.org/show_bug.cgi?id=49131, and
-+// https://bugs.llvm.org/show_bug.cgi?id=49132. Don't bother running these tests
-+// with double doubles until compiler support is better.
-+using RealTypes =
-+    std::conditional<absl::numeric_internal::IsDoubleDouble(),
-+                     ::testing::Types<float, double>,
-+                     ::testing::Types<float, double, long double>>::type;
- #endif  // defined(__EMSCRIPTEN__)
- TYPED_TEST_CASE(ExponentialDistributionTypedTest, RealTypes);
- 
-@@ -130,23 +139,6 @@ TYPED_TEST(ExponentialDistributionTypedTest, SerializeTest) {
- 
-     ss >> after;
- 
--#if defined(__powerpc64__) || defined(__PPC64__) || defined(__powerpc__) || \
--    defined(__ppc__) || defined(__PPC__)
--    if (std::is_same<TypeParam, long double>::value) {
--      // Roundtripping floating point values requires sufficient precision to
--      // reconstruct the exact value. It turns out that long double has some
--      // errors doing this on ppc, particularly for values
--      // near {1.0 +/- epsilon}.
--      if (lambda <= std::numeric_limits<double>::max() &&
--          lambda >= std::numeric_limits<double>::lowest()) {
--        EXPECT_EQ(static_cast<double>(before.lambda()),
--                  static_cast<double>(after.lambda()))
--            << ss.str();
--      }
--      continue;
--    }
--#endif
--
-     EXPECT_EQ(before.lambda(), after.lambda())  //
-         << ss.str() << " "                      //
-         << (ss.good() ? "good " : "")           //
---- a/absl/random/gaussian_distribution_test.cc
-+++ b/absl/random/gaussian_distribution_test.cc
-@@ -21,12 +21,14 @@
- #include <iterator>
- #include <random>
- #include <string>
-+#include <type_traits>
- #include <vector>
- 
- #include "gmock/gmock.h"
- #include "gtest/gtest.h"
- #include "absl/base/internal/raw_logging.h"
- #include "absl/base/macros.h"
-+#include "absl/numeric/internal/representation.h"
- #include "absl/random/internal/chi_square.h"
- #include "absl/random/internal/distribution_test_util.h"
- #include "absl/random/internal/sequence_urbg.h"
-@@ -43,7 +45,15 @@
- template <typename RealType>
- class GaussianDistributionInterfaceTest : public ::testing::Test {};
- 
--using RealTypes = ::testing::Types<float, double, long double>;
-+// double-double arithmetic is not supported well by either GCC or Clang; see
-+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99048,
-+// https://bugs.llvm.org/show_bug.cgi?id=49131, and
-+// https://bugs.llvm.org/show_bug.cgi?id=49132. Don't bother running these tests
-+// with double doubles until compiler support is better.
-+using RealTypes =
-+    std::conditional<absl::numeric_internal::IsDoubleDouble(),
-+                     ::testing::Types<float, double>,
-+                     ::testing::Types<float, double, long double>>::type;
- TYPED_TEST_CASE(GaussianDistributionInterfaceTest, RealTypes);
- 
- TYPED_TEST(GaussianDistributionInterfaceTest, SerializeTest) {
-@@ -129,32 +139,6 @@ TYPED_TEST(GaussianDistributionInterfaceTest, SerializeTest) {
- 
-         ss >> after;
- 
--#if defined(__powerpc64__) || defined(__PPC64__) || defined(__powerpc__) || \
--    defined(__ppc__) || defined(__PPC__) || defined(__EMSCRIPTEN__)
--        if (std::is_same<TypeParam, long double>::value) {
--          // Roundtripping floating point values requires sufficient precision
--          // to reconstruct the exact value.  It turns out that long double
--          // has some errors doing this on ppc, particularly for values
--          // near {1.0 +/- epsilon}.
--          //
--          // Emscripten is even worse, implementing long double as a 128-bit
--          // type, but shipping with a strtold() that doesn't support that.
--          if (mean <= std::numeric_limits<double>::max() &&
--              mean >= std::numeric_limits<double>::lowest()) {
--            EXPECT_EQ(static_cast<double>(before.mean()),
--                      static_cast<double>(after.mean()))
--                << ss.str();
--          }
--          if (stddev <= std::numeric_limits<double>::max() &&
--              stddev >= std::numeric_limits<double>::lowest()) {
--            EXPECT_EQ(static_cast<double>(before.stddev()),
--                      static_cast<double>(after.stddev()))
--                << ss.str();
--          }
--          continue;
--        }
--#endif
--
-         EXPECT_EQ(before.mean(), after.mean());
-         EXPECT_EQ(before.stddev(), after.stddev())  //
-             << ss.str() << " "                      //
---- a/absl/random/uniform_real_distribution_test.cc
-+++ b/absl/random/uniform_real_distribution_test.cc
-@@ -20,11 +20,13 @@
- #include <random>
- #include <sstream>
- #include <string>
-+#include <type_traits>
- #include <vector>
- 
- #include "gmock/gmock.h"
- #include "gtest/gtest.h"
- #include "absl/base/internal/raw_logging.h"
-+#include "absl/numeric/internal/representation.h"
- #include "absl/random/internal/chi_square.h"
- #include "absl/random/internal/distribution_test_util.h"
- #include "absl/random/internal/pcg_engine.h"
-@@ -58,7 +60,15 @@
- #if defined(__EMSCRIPTEN__)
- using RealTypes = ::testing::Types<float, double>;
- #else
--using RealTypes = ::testing::Types<float, double, long double>;
-+// double-double arithmetic is not supported well by either GCC or Clang; see
-+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99048,
-+// https://bugs.llvm.org/show_bug.cgi?id=49131, and
-+// https://bugs.llvm.org/show_bug.cgi?id=49132. Don't bother running these tests
-+// with double doubles until compiler support is better.
-+using RealTypes =
-+    std::conditional<absl::numeric_internal::IsDoubleDouble(),
-+                     ::testing::Types<float, double>,
-+                     ::testing::Types<float, double, long double>>::type;
- #endif  // defined(__EMSCRIPTEN__)
- 
- TYPED_TEST_SUITE(UniformRealDistributionTest, RealTypes);
---- a/absl/strings/BUILD.bazel
-+++ b/absl/strings/BUILD.bazel
-@@ -645,6 +645,7 @@ cc_library(name = "str_format_internal",
-         "//absl/functional:function_ref",
-         "//absl/meta:type_traits",
-         "//absl/numeric:int128",
-+        "//absl/numeric:representation",
-         "//absl/types:optional",
-         "//absl/types:span",
-     ],
---- a/absl/strings/CMakeLists.txt
-+++ b/absl/strings/CMakeLists.txt
-@@ -396,6 +396,7 @@ absl_cc_library(NAME str_format_internal
-     absl::strings
-     absl::config
-     absl::core_headers
-+    absl::numeric_representation
-     absl::type_traits
-     absl::int128
-     absl::span
---- a/absl/strings/internal/str_format/float_conversion.cc
-+++ b/absl/strings/internal/str_format/float_conversion.cc
-@@ -15,6 +15,7 @@
- #include "absl/functional/function_ref.h"
- #include "absl/meta/type_traits.h"
- #include "absl/numeric/int128.h"
-+#include "absl/numeric/internal/representation.h"
- #include "absl/strings/numbers.h"
- #include "absl/types/optional.h"
- #include "absl/types/span.h"
-@@ -25,6 +26,8 @@
- 
- namespace {
- 
-+using ::absl::numeric_internal::IsDoubleDouble;
-+
- // The code below wants to avoid heap allocations.
- // To do so it needs to allocate memory on the stack.
- // `StackArray` will allocate memory on the stack in the form of a uint32_t
-@@ -98,13 +101,6 @@
-   return next_carry % divisor;
- }
- 
--constexpr bool IsDoubleDouble() {
--  // This is the `double-double` representation of `long double`.
--  // We do not handle it natively. Fallback to snprintf.
--  return std::numeric_limits<long double>::digits ==
--         2 * std::numeric_limits<double>::digits;
--}
--
- using MaxFloatType =
-     typename std::conditional<IsDoubleDouble(), double, long double>::type;
- 
-@@ -1391,6 +1387,8 @@
- bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
-                       FormatSinkImpl *sink) {
-   if (IsDoubleDouble()) {
-+    // This is the `double-double` representation of `long double`. We do not
-+    // handle it natively. Fallback to snprintf.
-     return FallbackToSnprintf(v, conv, sink);
-   }
- 
diff --git a/debian/patches/endian-hash.diff b/debian/patches/endian-hash.diff
deleted file mode 100644
index 01c1b6b0..00000000
--- a/debian/patches/endian-hash.diff
+++ /dev/null
@@ -1,111 +0,0 @@
-From: Benjamin Barenblat <bbaren@google.com>
-Subject: Remove endian-sensitivity from hash slow path
-Forwarded: yes
-Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/9c6a50fdd80bb39fabd95faeda84f04062685ff3
-
-Prior to this commit, the Abseil hash fast path was endian-agnostic, but
-the slow path assumed a little-endian platform. Change the slow path to
-be endian-correct, ensuring that values produced by the fast and slow
-paths are equal even on big-endian systems.
-
-The author works at Google. Upstream applied this patch as Piper revision
-355424258 and exported it to GitHub; the Applied-Upstream URL above points to
-the exported commit.
-
---- a/absl/hash/BUILD.bazel
-+++ b/absl/hash/BUILD.bazel
-@@ -37,6 +37,7 @@ cc_library(name = "hash",
-     linkopts = ABSL_DEFAULT_LINKOPTS,
-     deps = [
-         ":city",
-+        "//absl/base:config",
-         "//absl/base:core_headers",
-         "//absl/base:endian",
-         "//absl/container:fixed_array",
---- a/absl/hash/CMakeLists.txt
-+++ b/absl/hash/CMakeLists.txt
-@@ -25,6 +25,7 @@ absl_cc_library(NAME hash
-   COPTS
-     ${ABSL_DEFAULT_COPTS}
-   DEPS
-+    absl::config
-     absl::core_headers
-     absl::endian
-     absl::fixed_array
---- a/absl/hash/internal/hash.h
-+++ b/absl/hash/internal/hash.h
-@@ -38,7 +38,8 @@
- #include <utility>
- #include <vector>
- 
--#include "absl/base/internal/endian.h"
-+#include "absl/base/config.h"
-+#include "absl/base/internal/unaligned_access.h"
- #include "absl/base/port.h"
- #include "absl/container/fixed_array.h"
- #include "absl/meta/type_traits.h"
-@@ -804,26 +805,54 @@ class ABSL_DLL CityHashState
-                                                size_t len);
- 
-   // Reads 9 to 16 bytes from p.
--  // The first 8 bytes are in .first, the rest (zero padded) bytes are in
--  // .second.
-+  // The least significant 8 bytes are in .first, the rest (zero padded) bytes
-+  // are in .second.
-   static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
-                                                  size_t len) {
--    uint64_t high = little_endian::Load64(p + len - 8);
--    return {little_endian::Load64(p), high >> (128 - len * 8)};
-+    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
-+    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
-+#ifdef ABSL_IS_LITTLE_ENDIAN
-+    uint64_t most_significant = high_mem;
-+    uint64_t least_significant = low_mem;
-+#else
-+    uint64_t most_significant = low_mem;
-+    uint64_t least_significant = high_mem;
-+#endif
-+    return {least_significant, most_significant >> (128 - len * 8)};
-   }
- 
-   // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
-   static uint64_t Read4To8(const unsigned char* p, size_t len) {
--    return (static_cast<uint64_t>(little_endian::Load32(p + len - 4))
--            << (len - 4) * 8) |
--           little_endian::Load32(p);
-+    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
-+    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
-+#ifdef ABSL_IS_LITTLE_ENDIAN
-+    uint32_t most_significant = high_mem;
-+    uint32_t least_significant = low_mem;
-+#else
-+    uint32_t most_significant = low_mem;
-+    uint32_t least_significant = high_mem;
-+#endif
-+    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
-+           least_significant;
-   }
- 
-   // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
-   static uint32_t Read1To3(const unsigned char* p, size_t len) {
--    return static_cast<uint32_t>((p[0]) |                         //
--                                 (p[len / 2] << (len / 2 * 8)) |  //
--                                 (p[len - 1] << ((len - 1) * 8)));
-+    unsigned char mem0 = p[0];
-+    unsigned char mem1 = p[len / 2];
-+    unsigned char mem2 = p[len - 1];
-+#ifdef ABSL_IS_LITTLE_ENDIAN
-+    unsigned char significant2 = mem2;
-+    unsigned char significant1 = mem1;
-+    unsigned char significant0 = mem0;
-+#else
-+    unsigned char significant2 = mem0;
-+    unsigned char significant1 = mem1;
-+    unsigned char significant0 = mem2;
-+#endif
-+    return static_cast<uint32_t>(significant0 |                     //
-+                                 (significant1 << (len / 2 * 8)) |  //
-+                                 (significant2 << ((len - 1) * 8)));
-   }
- 
-   ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
diff --git a/debian/patches/endian-random.diff b/debian/patches/endian-random.diff
deleted file mode 100644
index 9fe2b166..00000000
--- a/debian/patches/endian-random.diff
+++ /dev/null
@@ -1,249 +0,0 @@
-From: Benjamin Barenblat <bbaren@google.com>
-Subject: Remove endian-sensitivity from Abseil's RNG
-Forwarded: yes
-Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/c36d825d9a5443f81d2656685ae021d6326da90c
-
-Ensure that the Abseil random number generator produces identical output
-on both big- and little-endian platforms by byte-swapping appropriately
-on big-endian systems.
-
-The author works at Google. Upstream applied this patch as Piper
-revision 355635051 and exported it to GitHub; the Applied-Upstream URL
-above points to the exported commit.
-
---- a/absl/base/BUILD.bazel
-+++ b/absl/base/BUILD.bazel
-@@ -479,6 +479,7 @@
-     copts = ABSL_DEFAULT_COPTS,
-     linkopts = ABSL_DEFAULT_LINKOPTS,
-     deps = [
-+        ":base",
-         ":config",
-         ":core_headers",
-     ],
---- a/absl/base/CMakeLists.txt
-+++ b/absl/base/CMakeLists.txt
-@@ -418,6 +418,7 @@
-   COPTS
-     ${ABSL_DEFAULT_COPTS}
-   DEPS
-+    absl::base
-     absl::config
-     absl::core_headers
-   PUBLIC
---- a/absl/base/internal/endian.h
-+++ b/absl/base/internal/endian.h
-@@ -26,6 +26,7 @@
- #endif
- 
- #include <cstdint>
-+#include "absl/base/casts.h"
- #include "absl/base/config.h"
- #include "absl/base/internal/unaligned_access.h"
- #include "absl/base/port.h"
-@@ -173,6 +174,36 @@
- 
- #endif /* ENDIAN */
- 
-+inline uint8_t FromHost(uint8_t x) { return x; }
-+inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-+inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-+inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-+inline uint8_t ToHost(uint8_t x) { return x; }
-+inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-+inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-+inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-+
-+inline int8_t FromHost(int8_t x) { return x; }
-+inline int16_t FromHost(int16_t x) {
-+  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-+}
-+inline int32_t FromHost(int32_t x) {
-+  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-+}
-+inline int64_t FromHost(int64_t x) {
-+  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-+}
-+inline int8_t ToHost(int8_t x) { return x; }
-+inline int16_t ToHost(int16_t x) {
-+  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-+}
-+inline int32_t ToHost(int32_t x) {
-+  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-+}
-+inline int64_t ToHost(int64_t x) {
-+  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-+}
-+
- // Functions to do unaligned loads and stores in little-endian order.
- inline uint16_t Load16(const void *p) {
-   return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
-@@ -233,6 +264,36 @@
- 
- #endif /* ENDIAN */
- 
-+inline uint8_t FromHost(uint8_t x) { return x; }
-+inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-+inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-+inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-+inline uint8_t ToHost(uint8_t x) { return x; }
-+inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-+inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-+inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-+
-+inline int8_t FromHost(int8_t x) { return x; }
-+inline int16_t FromHost(int16_t x) {
-+  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-+}
-+inline int32_t FromHost(int32_t x) {
-+  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-+}
-+inline int64_t FromHost(int64_t x) {
-+  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-+}
-+inline int8_t ToHost(int8_t x) { return x; }
-+inline int16_t ToHost(int16_t x) {
-+  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-+}
-+inline int32_t ToHost(int32_t x) {
-+  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-+}
-+inline int64_t ToHost(int64_t x) {
-+  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-+}
-+
- // Functions to do unaligned loads and stores in big-endian order.
- inline uint16_t Load16(const void *p) {
-   return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
---- a/absl/random/CMakeLists.txt
-+++ b/absl/random/CMakeLists.txt
-@@ -611,6 +611,7 @@
-     ${ABSL_DEFAULT_LINKOPTS}
-   DEPS
-     absl::config
-+    absl::endian
-   TESTONLY
- )
- 
-@@ -758,6 +759,7 @@
-   LINKOPTS
-     ${ABSL_DEFAULT_LINKOPTS}
-   DEPS
-+    absl::endian
-     absl::random_internal_iostream_state_saver
-     absl::random_internal_randen
-     absl::raw_logging_internal
-@@ -1119,6 +1121,7 @@
-   LINKOPTS
-     ${ABSL_DEFAULT_LINKOPTS}
-   DEPS
-+    absl::endian
-     absl::random_internal_randen_slow
-     gtest_main
- )
---- a/absl/random/internal/BUILD.bazel
-+++ b/absl/random/internal/BUILD.bazel
-@@ -124,7 +124,10 @@
-     ],
-     copts = ABSL_DEFAULT_COPTS,
-     linkopts = ABSL_DEFAULT_LINKOPTS,
--    deps = ["//absl/base:config"],
-+    deps = [
-+        "//absl/base:config",
-+        "//absl/base:endian",
-+    ],
- )
- 
- cc_library(
-@@ -241,6 +244,7 @@
-     deps = [
-         ":iostream_state_saver",
-         ":randen",
-+        "//absl/base:endian",
-         "//absl/meta:type_traits",
-     ],
- )
-@@ -606,6 +610,7 @@
-         ":platform",
-         ":randen_slow",
-         "@com_google_googletest//:gtest_main",
-+        "//absl/base:endian",
-     ],
- )
- 
---- a/absl/random/internal/explicit_seed_seq.h
-+++ b/absl/random/internal/explicit_seed_seq.h
-@@ -23,6 +23,7 @@
- #include <vector>
- 
- #include "absl/base/config.h"
-+#include "absl/base/internal/endian.h"
- 
- namespace absl {
- ABSL_NAMESPACE_BEGIN
-@@ -73,7 +74,7 @@
-   template <typename OutIterator>
-   void generate(OutIterator begin, OutIterator end) {
-     for (size_t index = 0; begin != end; begin++) {
--      *begin = state_.empty() ? 0 : state_[index++];
-+      *begin = state_.empty() ? 0 : little_endian::FromHost32(state_[index++]);
-       if (index >= state_.size()) {
-         index = 0;
-       }
---- a/absl/random/internal/randen_engine.h
-+++ b/absl/random/internal/randen_engine.h
-@@ -23,6 +23,7 @@
- #include <limits>
- #include <type_traits>
- 
-+#include "absl/base/internal/endian.h"
- #include "absl/meta/type_traits.h"
- #include "absl/random/internal/iostream_state_saver.h"
- #include "absl/random/internal/randen.h"
-@@ -76,7 +77,7 @@
-       impl_.Generate(state_);
-     }
- 
--    return state_[next_++];
-+    return little_endian::ToHost(state_[next_++]);
-   }
- 
-   template <class SeedSequence>
-@@ -181,7 +182,8 @@
-       // In the case that `elem` is `uint8_t`, it must be cast to something
-       // larger so that it prints as an integer rather than a character. For
-       // simplicity, apply the cast all circumstances.
--      os << static_cast<numeric_type>(elem) << os.fill();
-+      os << static_cast<numeric_type>(little_endian::FromHost(elem))
-+         << os.fill();
-     }
-     os << engine.next_;
-     return os;
-@@ -200,7 +202,7 @@
-       // necessary to read a wider type and then cast it to uint8_t.
-       numeric_type value;
-       is >> value;
--      elem = static_cast<result_type>(value);
-+      elem = little_endian::ToHost(static_cast<result_type>(value));
-     }
-     is >> next;
-     if (is.fail()) {
---- a/absl/random/internal/randen_slow_test.cc
-+++ b/absl/random/internal/randen_slow_test.cc
-@@ -17,6 +17,7 @@
- #include <cstring>
- 
- #include "gtest/gtest.h"
-+#include "absl/base/internal/endian.h"
- #include "absl/random/internal/randen_traits.h"
- 
- namespace {
-@@ -56,7 +57,7 @@
- 
-   uint64_t* id = d.state;
-   for (const auto& elem : kGolden) {
--    EXPECT_EQ(elem, *id++);
-+    EXPECT_EQ(absl::little_endian::FromHost64(elem), *id++);
-   }
- }
- 
diff --git a/debian/patches/fix-hppa.diff b/debian/patches/fix-hppa.diff
deleted file mode 100644
index 915efff4..00000000
--- a/debian/patches/fix-hppa.diff
+++ /dev/null
@@ -1,26 +0,0 @@
-From: John David Anglin <dave.anglin@bell.net>
-Subject: Fix build on hppa
-Bug-Debian: https://bugs.debian.org/971768
-Reviewed-by: Benjamin Barenblat <bbaren@debian.org>
-
---- a/absl/base/internal/direct_mmap.h
-+++ b/absl/base/internal/direct_mmap.h
-@@ -74,6 +74,7 @@
- inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
-                         off64_t offset) noexcept {
- #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \
-+    (defined(__hppa__) && !defined(__LP64__)) ||                             \
-     (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) ||                   \
-     (defined(__PPC__) && !defined(__PPC64__)) ||                             \
-     (defined(__riscv) && __riscv_xlen == 32) ||                              \
---- a/absl/debugging/internal/examine_stack.cc
-+++ b/absl/debugging/internal/examine_stack.cc
-@@ -48,6 +48,8 @@
-     return reinterpret_cast<void*>(context->uc_mcontext.pc);
- #elif defined(__arm__)
-     return reinterpret_cast<void*>(context->uc_mcontext.arm_pc);
-+#elif defined(__hppa__)
-+    return reinterpret_cast<void*>(context->uc_mcontext.sc_iaoq[0]);
- #elif defined(__i386__)
-     if (14 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
-       return reinterpret_cast<void*>(context->uc_mcontext.gregs[14]);
diff --git a/debian/patches/fma-contraction.diff b/debian/patches/fma-contraction.diff
deleted file mode 100644
index 95181a36..00000000
--- a/debian/patches/fma-contraction.diff
+++ /dev/null
@@ -1,63 +0,0 @@
-From: Benjamin Barenblat <bbaren@google.com>
-Subject: Make tests tolerant of FMA contraction
-Forwarded: yes
-Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/b0735979d778a768caee207f01f327535cbd2140
-
-Weaken Duration.ToDoubleSecondsCheckEdgeCases and
-Duration.ToDoubleSecondsCheckRandom to make them less sensitive to fused
-multiply/add contraction.
-
-The author works at Google. Upstream applied this patch as Piper
-revision 360297653 and exported it to GitHub; the the Applied-Upstream URL
-above points to the exported commit.
-
---- a/absl/time/duration_test.cc
-+++ b/absl/time/duration_test.cc
-@@ -1369,10 +1369,13 @@
-   EXPECT_THAT(ToTimeval(absl::Nanoseconds(2000)), TimevalMatcher(tv));
- }
- 
--void VerifySameAsMul(double time_as_seconds, int* const misses) {
-+void VerifyApproxSameAsMul(double time_as_seconds, int* const misses) {
-   auto direct_seconds = absl::Seconds(time_as_seconds);
-   auto mul_by_one_second = time_as_seconds * absl::Seconds(1);
--  if (direct_seconds != mul_by_one_second) {
-+  // These are expected to differ by up to one tick due to fused multiply/add
-+  // contraction.
-+  if (absl::AbsDuration(direct_seconds - mul_by_one_second) >
-+      absl::time_internal::MakeDuration(0, 1u)) {
-     if (*misses > 10) return;
-     ASSERT_LE(++(*misses), 10) << "Too many errors, not reporting more.";
-     EXPECT_EQ(direct_seconds, mul_by_one_second)
-@@ -1384,7 +1387,8 @@
- // For a variety of interesting durations, we find the exact point
- // where one double converts to that duration, and the very next double
- // converts to the next duration.  For both of those points, verify that
--// Seconds(point) returns the same duration as point * Seconds(1.0)
-+// Seconds(point) returns a duration near point * Seconds(1.0). (They may
-+// not be exactly equal due to fused multiply/add contraction.)
- TEST(Duration, ToDoubleSecondsCheckEdgeCases) {
-   constexpr uint32_t kTicksPerSecond = absl::time_internal::kTicksPerSecond;
-   constexpr auto duration_tick = absl::time_internal::MakeDuration(0, 1u);
-@@ -1423,8 +1427,8 @@
-         }
-         // Now low_edge is the highest double that converts to Duration d,
-         // and high_edge is the lowest double that converts to Duration after_d.
--        VerifySameAsMul(low_edge, &misses);
--        VerifySameAsMul(high_edge, &misses);
-+        VerifyApproxSameAsMul(low_edge, &misses);
-+        VerifyApproxSameAsMul(high_edge, &misses);
-       }
-     }
-   }
-@@ -1444,8 +1448,8 @@
-   int misses = 0;
-   for (int i = 0; i < 1000000; ++i) {
-     double d = std::exp(uniform(gen));
--    VerifySameAsMul(d, &misses);
--    VerifySameAsMul(-d, &misses);
-+    VerifyApproxSameAsMul(d, &misses);
-+    VerifyApproxSameAsMul(-d, &misses);
-   }
- }
- 
diff --git a/debian/patches/latomic.diff b/debian/patches/latomic.diff
index d78c7469..50e170e4 100644
--- a/debian/patches/latomic.diff
+++ b/debian/patches/latomic.diff
@@ -9,7 +9,7 @@ if anything needs libatomic and add the DT_NEEDED entry where necessary.
 
 --- a/absl/copts/AbseilConfigureCopts.cmake
 +++ b/absl/copts/AbseilConfigureCopts.cmake
-@@ -64,4 +64,8 @@
+@@ -63,4 +63,8 @@
    set(ABSL_TEST_COPTS "")
  endif()
  
diff --git a/debian/patches/nan-narrowing.diff b/debian/patches/nan-narrowing.diff
deleted file mode 100644
index c7ec9325..00000000
--- a/debian/patches/nan-narrowing.diff
+++ /dev/null
@@ -1,25 +0,0 @@
-From: Benjamin Barenblat <bbaren@google.com>
-Subject: Avoid libgcc -NaN narrowing bug
-Forwarded: yes
-Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/1bae23e32ba1f1af7c7d1488a69a351ec96dc98d
-
-When testing -NaN parsing, avoid narrowing -NaN from double to float. This
-avoids a bug in libgcc (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98251).
-
-The author works at Google. Upstream applied this patch as Piper revision
-347654751 and exported it to GitHub; the Applied-Upstream URL above points to
-the exported commit.
-
---- a/absl/strings/charconv_test.cc
-+++ b/absl/strings/charconv_test.cc
-@@ -653,7 +653,9 @@ TEST(FromChars, NaNFloats) {
-                      negative_from_chars_float);
-     EXPECT_TRUE(std::signbit(negative_from_chars_float));
-     EXPECT_FALSE(Identical(negative_from_chars_float, from_chars_float));
--    from_chars_float = std::copysign(from_chars_float, -1.0);
-+    // Use the (float, float) overload of std::copysign to prevent narrowing;
-+    // see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98251.
-+    from_chars_float = std::copysign(from_chars_float, -1.0f);
-     EXPECT_TRUE(Identical(negative_from_chars_float, from_chars_float));
-   }
- }
diff --git a/debian/patches/ppc-float-conversion.diff b/debian/patches/ppc-float-conversion.diff
deleted file mode 100644
index f0ff9595..00000000
--- a/debian/patches/ppc-float-conversion.diff
+++ /dev/null
@@ -1,268 +0,0 @@
-From: Samuel Benzaquen <sbenza@google.com>
-Subject: Fix float conversion for PPC.
-Origin: backport, https://github.com/abseil/abseil-cpp/commit/c36d825d9a5443f81d2656685ae021d6326da90c
-
-In PPC `long double` is a double-double representation which behaves weirdly
-wrt numeric_limits. Don't take `long double` into account when we are not
-handling `long double` natively anyway.
-
-Fix the convert test to always run the conversion even if we are not going to
-compare against libc's printf result. This allows exercising the code itself to
-make sure we don't trigger assertions or UB found by sanitizers.
-
-The author works at Google. Upstream applied this patch as Piper revision
-355857729 and exported it to GitHub; the Applied-Upstream URL above points to
-the exported commit.
-
---- a/absl/strings/internal/str_format/convert_test.cc
-+++ b/absl/strings/internal/str_format/convert_test.cc
-@@ -540,7 +540,8 @@
- }
- 
- template <typename Floating>
--void TestWithMultipleFormatsHelper(const std::vector<Floating> &floats) {
-+void TestWithMultipleFormatsHelper(const std::vector<Floating> &floats,
-+                                   const std::set<Floating> &skip_verify) {
-   const NativePrintfTraits &native_traits = VerifyNativeImplementation();
-   // Reserve the space to ensure we don't allocate memory in the output itself.
-   std::string str_format_result;
-@@ -588,7 +589,16 @@
-           AppendPack(&str_format_result, format, absl::MakeSpan(args));
-         }
- 
--        if (string_printf_result != str_format_result) {
-+#ifdef _MSC_VER
-+        // MSVC has a different rounding policy than us so we can't test our
-+        // implementation against the native one there.
-+        continue;
-+#elif defined(__APPLE__)
-+        // Apple formats NaN differently (+nan) vs. (nan)
-+        if (std::isnan(d)) continue;
-+#endif
-+        if (string_printf_result != str_format_result &&
-+            skip_verify.find(d) == skip_verify.end()) {
-           // We use ASSERT_EQ here because failures are usually correlated and a
-           // bug would print way too many failed expectations causing the test
-           // to time out.
-@@ -602,12 +612,6 @@
- }
- 
- TEST_F(FormatConvertTest, Float) {
--#ifdef _MSC_VER
--  // MSVC has a different rounding policy than us so we can't test our
--  // implementation against the native one there.
--  return;
--#endif  // _MSC_VER
--
-   std::vector<float> floats = {0.0f,
-                                -0.0f,
-                                .9999999f,
-@@ -621,7 +625,8 @@
-                                std::numeric_limits<float>::epsilon(),
-                                std::numeric_limits<float>::epsilon() + 1.0f,
-                                std::numeric_limits<float>::infinity(),
--                               -std::numeric_limits<float>::infinity()};
-+                               -std::numeric_limits<float>::infinity(),
-+                               std::nanf("")};
- 
-   // Some regression tests.
-   floats.push_back(0.999999989f);
-@@ -650,21 +655,14 @@
-   std::sort(floats.begin(), floats.end());
-   floats.erase(std::unique(floats.begin(), floats.end()), floats.end());
- 
--#ifndef __APPLE__
--  // Apple formats NaN differently (+nan) vs. (nan)
--  floats.push_back(std::nan(""));
--#endif
--
--  TestWithMultipleFormatsHelper(floats);
-+  TestWithMultipleFormatsHelper(floats, {});
- }
- 
- TEST_F(FormatConvertTest, Double) {
--#ifdef _MSC_VER
--  // MSVC has a different rounding policy than us so we can't test our
--  // implementation against the native one there.
--  return;
--#endif  // _MSC_VER
--
-+  // For values that we know won't match the standard library implementation we
-+  // skip verification, but still run the algorithm to catch asserts/sanitizer
-+  // bugs.
-+  std::set<double> skip_verify;
-   std::vector<double> doubles = {0.0,
-                                  -0.0,
-                                  .99999999999999,
-@@ -678,7 +676,8 @@
-                                  std::numeric_limits<double>::epsilon(),
-                                  std::numeric_limits<double>::epsilon() + 1,
-                                  std::numeric_limits<double>::infinity(),
--                                 -std::numeric_limits<double>::infinity()};
-+                                 -std::numeric_limits<double>::infinity(),
-+                                 std::nan("")};
- 
-   // Some regression tests.
-   doubles.push_back(0.99999999999999989);
-@@ -708,33 +707,29 @@
-       "5084551339423045832369032229481658085593321233482747978262041447231"
-       "68738177180919299881250404026184124858368.000000";
- 
--  if (!gcc_bug_22142) {
--    for (int exp = -300; exp <= 300; ++exp) {
--      const double all_ones_mantissa = 0x1fffffffffffff;
--      doubles.push_back(std::ldexp(all_ones_mantissa, exp));
-+  for (int exp = -300; exp <= 300; ++exp) {
-+    const double all_ones_mantissa = 0x1fffffffffffff;
-+    doubles.push_back(std::ldexp(all_ones_mantissa, exp));
-+    if (gcc_bug_22142) {
-+      skip_verify.insert(doubles.back());
-     }
-   }
- 
-   if (gcc_bug_22142) {
--    for (auto &d : doubles) {
--      using L = std::numeric_limits<double>;
--      double d2 = std::abs(d);
--      if (d2 == L::max() || d2 == L::min() || d2 == L::denorm_min()) {
--        d = 0;
--      }
--    }
-+    using L = std::numeric_limits<double>;
-+    skip_verify.insert(L::max());
-+    skip_verify.insert(L::min());  // NOLINT
-+    skip_verify.insert(L::denorm_min());
-+    skip_verify.insert(-L::max());
-+    skip_verify.insert(-L::min());  // NOLINT
-+    skip_verify.insert(-L::denorm_min());
-   }
- 
-   // Remove duplicates to speed up the logic below.
-   std::sort(doubles.begin(), doubles.end());
-   doubles.erase(std::unique(doubles.begin(), doubles.end()), doubles.end());
- 
--#ifndef __APPLE__
--  // Apple formats NaN differently (+nan) vs. (nan)
--  doubles.push_back(std::nan(""));
--#endif
--
--  TestWithMultipleFormatsHelper(doubles);
-+  TestWithMultipleFormatsHelper(doubles, skip_verify);
- }
- 
- TEST_F(FormatConvertTest, DoubleRound) {
-@@ -1055,11 +1050,6 @@
- }
- 
- TEST_F(FormatConvertTest, LongDouble) {
--#ifdef _MSC_VER
--  // MSVC has a different rounding policy than us so we can't test our
--  // implementation against the native one there.
--  return;
--#endif  // _MSC_VER
-   const NativePrintfTraits &native_traits = VerifyNativeImplementation();
-   const char *const kFormats[] = {"%",    "%.3", "%8.5", "%9",  "%.5000",
-                                   "%.60", "%+",  "% ",   "%-10"};
-@@ -1120,10 +1110,18 @@
-       for (auto d : doubles) {
-         FormatArgImpl arg(d);
-         UntypedFormatSpecImpl format(fmt_str);
-+        std::string result = FormatPack(format, {&arg, 1});
-+
-+#ifdef _MSC_VER
-+        // MSVC has a different rounding policy than us so we can't test our
-+        // implementation against the native one there.
-+        continue;
-+#endif  // _MSC_VER
-+
-         // We use ASSERT_EQ here because failures are usually correlated and a
-         // bug would print way too many failed expectations causing the test to
-         // time out.
--        ASSERT_EQ(StrPrint(fmt_str.c_str(), d), FormatPack(format, {&arg, 1}))
-+        ASSERT_EQ(StrPrint(fmt_str.c_str(), d), result)
-             << fmt_str << " " << StrPrint("%.18Lg", d) << " "
-             << StrPrint("%La", d) << " " << StrPrint("%.1080Lf", d);
-       }
---- a/absl/strings/internal/str_format/float_conversion.cc
-+++ b/absl/strings/internal/str_format/float_conversion.cc
-@@ -98,12 +98,22 @@
-   return next_carry % divisor;
- }
- 
-+constexpr bool IsDoubleDouble() {
-+  // This is the `double-double` representation of `long double`.
-+  // We do not handle it natively. Fallback to snprintf.
-+  return std::numeric_limits<long double>::digits ==
-+         2 * std::numeric_limits<double>::digits;
-+}
-+
-+using MaxFloatType =
-+    typename std::conditional<IsDoubleDouble(), double, long double>::type;
-+
- // Generates the decimal representation for an integer of the form `v * 2^exp`,
- // where `v` and `exp` are both positive integers.
- // It generates the digits from the left (ie the most significant digit first)
- // to allow for direct printing into the sink.
- //
--// Requires `0 <= exp` and `exp <= numeric_limits<long double>::max_exponent`.
-+// Requires `0 <= exp` and `exp <= numeric_limits<MaxFloatType>::max_exponent`.
- class BinaryToDecimal {
-   static constexpr int ChunksNeeded(int exp) {
-     // We will left shift a uint128 by `exp` bits, so we need `128+exp` total
-@@ -118,10 +128,10 @@
-   static void RunConversion(uint128 v, int exp,
-                             absl::FunctionRef<void(BinaryToDecimal)> f) {
-     assert(exp > 0);
--    assert(exp <= std::numeric_limits<long double>::max_exponent);
-+    assert(exp <= std::numeric_limits<MaxFloatType>::max_exponent);
-     static_assert(
-         StackArray::kMaxCapacity >=
--            ChunksNeeded(std::numeric_limits<long double>::max_exponent),
-+            ChunksNeeded(std::numeric_limits<MaxFloatType>::max_exponent),
-         "");
- 
-     StackArray::RunWithCapacity(
-@@ -218,14 +228,14 @@
- 
- // Converts a value of the form `x * 2^-exp` into a sequence of decimal digits.
- // Requires `-exp < 0` and
--// `-exp >= limits<long double>::min_exponent - limits<long double>::digits`.
-+// `-exp >= limits<MaxFloatType>::min_exponent - limits<MaxFloatType>::digits`.
- class FractionalDigitGenerator {
-  public:
-   // Run the conversion for `v * 2^exp` and call `f(generator)`.
-   // This function will allocate enough stack space to perform the conversion.
-   static void RunConversion(
-       uint128 v, int exp, absl::FunctionRef<void(FractionalDigitGenerator)> f) {
--    using Limits = std::numeric_limits<long double>;
-+    using Limits = std::numeric_limits<MaxFloatType>;
-     assert(-exp < 0);
-     assert(-exp >= Limits::min_exponent - 128);
-     static_assert(StackArray::kMaxCapacity >=
-@@ -858,10 +868,10 @@
-   // This buffer holds the "0x1.ab1de3" portion of "0x1.ab1de3pe+2". Compute the
-   // size with long double which is the largest of the floats.
-   constexpr size_t kBufSizeForHexFloatRepr =
--      2                                               // 0x
--      + std::numeric_limits<long double>::digits / 4  // number of hex digits
--      + 1                                             // round up
--      + 1;                                            // "." (dot)
-+      2                                                // 0x
-+      + std::numeric_limits<MaxFloatType>::digits / 4  // number of hex digits
-+      + 1                                              // round up
-+      + 1;                                             // "." (dot)
-   char digits_buffer[kBufSizeForHexFloatRepr];
-   char *digits_iter = digits_buffer;
-   const char *const digits =
-@@ -1380,10 +1390,7 @@
- 
- bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
-                       FormatSinkImpl *sink) {
--  if (std::numeric_limits<long double>::digits ==
--      2 * std::numeric_limits<double>::digits) {
--    // This is the `double-double` representation of `long double`.
--    // We do not handle it natively. Fallback to snprintf.
-+  if (IsDoubleDouble()) {
-     return FallbackToSnprintf(v, conv, sink);
-   }
- 
diff --git a/debian/patches/series b/debian/patches/series
index efe60449..9dec17a0 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,11 +1,3 @@
 configure.diff
-fix-hppa.diff
 std-hash.diff
 latomic.diff
-cpu-frequency.diff
-nan-narrowing.diff
-endian-hash.diff
-endian-random.diff
-ppc-float-conversion.diff
-fma-contraction.diff
-disable-double-double-tests.diff