diff options
Diffstat (limited to 'debian')
27 files changed, 1720 insertions, 0 deletions
diff --git a/debian/README.Debian b/debian/README.Debian new file mode 100644 index 00000000..7c0dd3c0 --- /dev/null +++ b/debian/README.Debian @@ -0,0 +1,9 @@ +Abseil for Debian +----------------- + +libabsl-dev installs a number of files to 'internal' directories. In general, +your project should not directly include any files from these directories; they +may change without warning. If you think you need something from one of those +files, please report a bug with reportbug(1). + + -- Benjamin Barenblat <bbaren@debian.org> Thu, 07 May 2020 11:35:28 -0400 diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 00000000..0b5309ae --- /dev/null +++ b/debian/changelog @@ -0,0 +1,163 @@ +abseil (20230125.3-2) experimental; urgency=medium + + * Reenable unit tests, which were accidentally disabled in the previous + version. + * Backport an upstream patch to allow building tests on mipsel. + * Backport a patch from upstream to correct symbolization on ppc64, and + enable unit tests on that platform. + + -- Benjamin Barenblat <bbaren@debian.org> Wed, 02 Aug 2023 14:06:31 -0400 + +abseil (20230125.3-1) experimental; urgency=medium + + * New upstream release. (Closes: #1033466, #1034908) + * Run tests serially on riscv64 to avoid hitting Debian build hardware + limits. (Closes: #1025221) + + -- Benjamin Barenblat <bbaren@debian.org> Sun, 14 May 2023 19:12:11 -0400 + +abseil (20220623.1-1) unstable; urgency=medium + + * New upstream release. + + -- Benjamin Barenblat <bbaren@debian.org> Tue, 18 Oct 2022 10:02:49 -0400 + +abseil (0~20220623.0-2) unstable; urgency=medium + + * Backport an upstream patch to correct pkg-config file generation. + + -- Benjamin Barenblat <bbaren@debian.org> Tue, 30 Aug 2022 22:54:45 -0400 + +abseil (0~20220623.0-1) unstable; urgency=medium + + * New upstream release. (Closes: #1008730, #1012194) + + -- Benjamin Barenblat <bbaren@debian.org> Mon, 22 Aug 2022 22:17:36 -0400 + +abseil (0~20210324.2-4) unstable; urgency=medium + + * Fix "spurious -Wl flag in some pkg-config entries" by backporting a + patch from upstream that corrects CMake pkg-config generation. + (Closes: #1011294) + + -- Benjamin Barenblat <bbaren@debian.org> Fri, 27 May 2022 16:58:38 -0400 + +abseil (0~20210324.2-3) unstable; urgency=medium + + * Backport an upstream patch to disable a problematic unit test. + (Closes: #1007136) + * Reenable unit tests on hppa. + + -- Benjamin Barenblat <bbaren@debian.org> Thu, 14 Apr 2022 13:20:16 -0400 + +abseil (0~20210324.2-2) unstable; urgency=medium + + * Disable a test that doesn’t play well with multiarch on armel and + armhf. + + -- Benjamin Barenblat <bbaren@debian.org> Mon, 07 Feb 2022 11:54:21 -0500 + +abseil (0~20210324.2-1) experimental; urgency=medium + + * New upstream release. + * Stop installing libabsl_flags.so and libabsl_flags.a, since they are + empty on every platform that Debian supports. + * Correct debian/watch search URLs to avoid picking up rc versions. + * Mangle upstream version in debian/watch to match manual mangling in + debian/changelog. + * Stop forcing -Wl,--no-as-needed on dependents. (Closes: #1001596) + * Compute Thumb function bounds correctly. (Closes: #987314) + * Reenable unit tests on most architectures. + + -- Benjamin Barenblat <bbaren@debian.org> Fri, 04 Feb 2022 13:11:32 -0500 + +abseil (0~20200923.3-3) unstable; urgency=medium + + * Fix "ftbfs with -march=x86-64-v3" by correcting the relevant unit + tests. (Closes: #983936) + * Disable double-double unit tests due to compiler bugs. + * Reenable unit tests on ppc64el. + + -- Benjamin Barenblat <bbaren@debian.org> Fri, 05 Mar 2021 15:57:38 -0500 + +abseil (0~20200923.3-2) unstable; urgency=medium + + * Correct string formatting on POWER. + + -- Benjamin Barenblat <bbaren@debian.org> Tue, 09 Feb 2021 14:41:06 -0500 + +abseil (0~20200923.3-1) unstable; urgency=medium + + * New upstream release. + * Correct endianness issues in hash functions and RNG. + + -- Benjamin Barenblat <bbaren@debian.org> Mon, 08 Feb 2021 15:04:52 -0500 + +abseil (0~20200923.2-3) unstable; urgency=medium + + * Fix some issues in unit tests. + * Re-disable unit tests on most platforms until they’re working + everywhere. + + -- Benjamin Barenblat <bbaren@debian.org> Sun, 31 Jan 2021 15:13:51 -0500 + +abseil (0~20200923.2-2) unstable; urgency=medium + + * Reenable unit tests. + + -- Benjamin Barenblat <bbaren@debian.org> Tue, 01 Dec 2020 12:37:56 -0500 + +abseil (0~20200923.2-1) unstable; urgency=medium + + * New upstream release. + * Fix build on hppa via patch. (Closes: #971768) + * Link libatomic where necessary to prevent issues with load-time + symbol resolution. (Closes: #973492) + + -- Benjamin Barenblat <bbaren@debian.org> Fri, 06 Nov 2020 16:51:39 -0500 + +abseil (0~20200923.1-1) unstable; urgency=medium + + * New upstream release. + + -- Benjamin Barenblat <bbaren@debian.org> Mon, 12 Oct 2020 12:40:50 -0400 + +abseil (0~20200923-2) unstable; urgency=medium + + * Release for unstable. + + -- Benjamin Barenblat <bbaren@debian.org> Tue, 06 Oct 2020 10:00:02 -0400 + +abseil (0~20200923-1) experimental; urgency=medium + + * New upstream release. + + -- Benjamin Barenblat <bbaren@debian.org> Fri, 25 Sep 2020 17:57:31 -0400 + +abseil (0~20200225.2-4) unstable; urgency=medium + + * Fix "autopkgtest needs update for new version of cmake: warning on + stderr" by applying a patch from upstream. (Closes: #970333) + + -- Benjamin Barenblat <bbaren@debian.org> Mon, 14 Sep 2020 17:40:05 -0400 + +abseil (0~20200225.2-3) unstable; urgency=medium + + * Replace symbols file with shlibs infrastructure. (Closes: #966183) + + -- Benjamin Barenblat <bbaren@debian.org> Fri, 24 Jul 2020 09:42:03 -0400 + +abseil (0~20200225.2-2) unstable; urgency=medium + + * Rebuild for unstable. + * Rework symbols file using pkg-kde-tools for increased robustness. + * Avoid SSSE3 on amd64 and SSE2 on i386 for greater processor + compatibility. + + -- Benjamin Barenblat <bbaren@debian.org> Thu, 23 Jul 2020 17:23:57 -0400 + +abseil (0~20200225.2-1) experimental; urgency=medium + + * Initial release. (Closes: #888705) + + -- Benjamin Barenblat <bbaren@debian.org> Thu, 18 Jun 2020 16:27:49 -0400 diff --git a/debian/control b/debian/control new file mode 100644 index 00000000..c7efcda4 --- /dev/null +++ b/debian/control @@ -0,0 +1,59 @@ +# 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. + +Source: abseil +Priority: optional +Maintainer: Benjamin Barenblat <bbaren@debian.org> +Build-Depends: + cmake (>= 3.10), + debhelper-compat (= 12), + googletest (>= 1.12), +Rules-Requires-Root: no +Standards-Version: 4.6.2 +Section: libs +Homepage: https://abseil.io/ +Vcs-Browser: https://salsa.debian.org/debian/abseil +Vcs-Git: https://salsa.debian.org/debian/abseil.git +Description: extensions to the C++ standard library + Abseil is an open-source collection of C++ library code designed to augment the + C++ standard library. The Abseil library code is collected from Google's C++ + codebase and has been extensively tested and used in production. In some cases, + Abseil provides pieces missing from the C++ standard; in others, Abseil + provides alternatives to the standard for special needs. + +Package: libabsl-dev +Architecture: any +Multi-Arch: same +Section: libdevel +Depends: + libabsl20230125 (= ${binary:Version}), + ${misc:Depends}, +Recommends: + cmake (>= 3.0) | pkg-config, + g++ (>= 5.1), + libgmock-dev (>= 1.12), +Description: ${source:Synopsis} (development files) + ${source:Extended-Description} + . + This package contains header files and other data necessary for developing with + Abseil. + +Package: libabsl20230125 +Architecture: any +Multi-Arch: same +Depends: ${shlibs:Depends}, ${misc:Depends} +Description: ${source:Synopsis} + ${source:Extended-Description} + . + This package contains Abseil's shared libraries. diff --git a/debian/copyright b/debian/copyright new file mode 100644 index 00000000..19a3388c --- /dev/null +++ b/debian/copyright @@ -0,0 +1,31 @@ +Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Upstream-Name: Abseil +Upstream-Contact: abseil-io@googlegroups.com +Source: https://github.com/abseil/abseil-cpp/ +Copyright: 2017 The Abseil Authors +License: Apache-2.0 + +Files: * +Copyright: + 2000-2017 Google Inc. + 2017-2023 The Abseil Authors +License: Apache-2.0 + +Files: debian/* +Copyright: 2020-2022 Google LLC +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 + 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. + . + On Debian systems, the complete text of the Apache License, Version 2.0, can be + found in "/usr/share/common-licenses/Apache-2.0". diff --git a/debian/gbp.conf b/debian/gbp.conf new file mode 100644 index 00000000..2c357e2c --- /dev/null +++ b/debian/gbp.conf @@ -0,0 +1,16 @@ +# 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. + +[DEFAULT] +upstream-tag = 20230125.3 diff --git a/debian/libabsl-dev.install b/debian/libabsl-dev.install new file mode 100644 index 00000000..9e2cb20e --- /dev/null +++ b/debian/libabsl-dev.install @@ -0,0 +1,19 @@ +# 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. + +usr/include/absl +usr/lib/*/*.a +usr/lib/*/*.so +usr/lib/*/cmake +usr/lib/*/pkgconfig/*.pc diff --git a/debian/libabsl-dev.lintian-overrides b/debian/libabsl-dev.lintian-overrides new file mode 100644 index 00000000..6765e8c9 --- /dev/null +++ b/debian/libabsl-dev.lintian-overrides @@ -0,0 +1,18 @@ +# Copyright 2022 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-dev: no-code-sections [usr/lib/*/libabsl_log_entry.*] +libabsl-dev: no-code-sections [usr/lib/*/libabsl_log_internal_nullguard.*] +libabsl-dev: no-code-sections [usr/lib/*/libabsl_random_internal_platform.*] +libabsl-dev: no-code-sections [usr/lib/*/libabsl_test_instance_tracker.*] diff --git a/debian/libabsl20230125.install b/debian/libabsl20230125.install new file mode 100644 index 00000000..ab3017e5 --- /dev/null +++ b/debian/libabsl20230125.install @@ -0,0 +1,15 @@ +# 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. + +usr/lib/*/libabsl_*.so.* diff --git a/debian/libabsl20230125.lintian-overrides b/debian/libabsl20230125.lintian-overrides new file mode 100644 index 00000000..3ce73081 --- /dev/null +++ b/debian/libabsl20230125.lintian-overrides @@ -0,0 +1,45 @@ +# Copyright 2022 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. + +libabsl20230125: hardening-no-fortify-functions [usr/lib/*/libabsl_base.so*] +libabsl20230125: hardening-no-fortify-functions [usr/lib/*/libabsl_debugging_internal.so*] +libabsl20230125: hardening-no-fortify-functions [usr/lib/*/libabsl_random_internal_seed_material.so*] +libabsl20230125: hardening-no-fortify-functions [usr/lib/*/libabsl_time_zone.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_bad_any_cast_impl.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_bad_optional_access.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_bad_variant_access.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_cordz_functions.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_cordz_sample_token.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_exponential_biased.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_flags_commandlineflag.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_flags_commandlineflag_internal.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_hash.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_log_initialize.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_log_internal_conditions.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_log_severity.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_log_sink.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_periodic_sampler.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_random_internal_randen.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_random_internal_randen_hwaes_impl.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_random_internal_randen_slow.so*] +libabsl20230125: library-not-linked-against-libc [usr/lib/*/libabsl_random_seed_gen_exception.so*] +libabsl20230125: no-symbols-control-file usr/lib/*/libabsl_* +libabsl20230125: package-name-doesnt-match-sonames libabsl-* +libabsl20230125: shared-library-lacks-prerequisites [usr/lib/*/libabsl_city.so*] +libabsl20230125: shared-library-lacks-prerequisites [usr/lib/*/libabsl_leak_check.so*] +libabsl20230125: shared-library-lacks-prerequisites [usr/lib/*/libabsl_log_entry.so*] +libabsl20230125: shared-library-lacks-prerequisites [usr/lib/*/libabsl_log_internal_nullguard.so*] +libabsl20230125: shared-library-lacks-prerequisites [usr/lib/*/libabsl_low_level_hash.so*] +libabsl20230125: shared-library-lacks-prerequisites [usr/lib/*/libabsl_random_internal_platform.so*] +libabsl20230125: shared-library-lacks-prerequisites [usr/lib/*/libabsl_random_internal_randen_hwaes.so*] diff --git a/debian/libabsl20230125.shlibs b/debian/libabsl20230125.shlibs new file mode 100644 index 00000000..2997d79a --- /dev/null +++ b/debian/libabsl20230125.shlibs @@ -0,0 +1,96 @@ +# Copyright 2022 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 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_bad_optional_access 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_bad_variant_access 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_base 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_city 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_civil_time 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_cord 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_cord_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_cordz_functions 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_cordz_handle 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_cordz_info 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_cordz_sample_token 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_crc32c 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_crc_cord_state 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_crc_cpu_detect 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_crc_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_debugging_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_demangle_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_die_if_null 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_examine_stack 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_exponential_biased 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_failure_signal_handler 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_commandlineflag 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_commandlineflag_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_config 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_marshalling 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_parse 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_private_handle_accessor 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_program_name 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_reflection 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_usage 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_flags_usage_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_graphcycles_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_hash 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_hashtablez_sampler 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_int128 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_leak_check 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_entry 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_flags 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_globals 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_initialize 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_check_op 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_conditions 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_format 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_globals 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_log_sink_set 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_message 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_nullguard 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_internal_proto 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_severity 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_log_sink 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_low_level_hash 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_malloc_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_periodic_sampler 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_distributions 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_distribution_test_util 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_platform 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_pool_urbg 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_randen 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_randen_hwaes 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_randen_hwaes_impl 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_randen_slow 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_internal_seed_material 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_seed_gen_exception 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_random_seed_sequences 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_raw_hash_set 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_raw_logging_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_scoped_set_env 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_spinlock_wait 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_stacktrace 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_status 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_statusor 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_str_format_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_strerror 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_strings 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_strings_internal 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_symbolize 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_synchronization 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_throw_delegate 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_time 20230125 libabsl20230125 (>= 20230125.0-1) +libabsl_time_zone 20230125 libabsl20230125 (>= 20230125.0-1) diff --git a/debian/patches/configure.diff b/debian/patches/configure.diff new file mode 100644 index 00000000..9d1fe736 --- /dev/null +++ b/debian/patches/configure.diff @@ -0,0 +1,82 @@ +From: Benjamin Barenblat <bbaren@google.com> +Subject: Set package configuration options +Forwarded: not-needed + +Configure Abseil for Debian. + + - Set the SONAME appropriately. + + - To minimize the possibility of future ABI breakage, treat absl::any, + absl::optional, absl::string_view, and absl::variant as their own types + (rather than aliases for the std:: versions), and compile everything in an + inline namespace. + + - Enable upstream's hardened build mode. + +--- a/CMake/AbseilHelpers.cmake ++++ b/CMake/AbseilHelpers.cmake +@@ -309,7 +309,8 @@ + if(ABSL_ENABLE_INSTALL) + set_target_properties(${_NAME} PROPERTIES + OUTPUT_NAME "absl_${_NAME}" +- SOVERSION "2301.0.0" ++ SOVERSION 20230125 ++ VERSION "20230125.0.0" + ) + endif() + else() +--- a/absl/base/options.h ++++ b/absl/base/options.h +@@ -94,7 +94,7 @@ + // User code should not inspect this macro. To check in the preprocessor if + // absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY. + +-#define ABSL_OPTION_USE_STD_ANY 2 ++#define ABSL_OPTION_USE_STD_ANY 0 + + + // ABSL_OPTION_USE_STD_OPTIONAL +@@ -121,7 +121,7 @@ + // absl::optional is a typedef of std::optional, use the feature macro + // ABSL_USES_STD_OPTIONAL. + +-#define ABSL_OPTION_USE_STD_OPTIONAL 2 ++#define ABSL_OPTION_USE_STD_OPTIONAL 0 + + + // ABSL_OPTION_USE_STD_STRING_VIEW +@@ -148,7 +148,7 @@ + // absl::string_view is a typedef of std::string_view, use the feature macro + // ABSL_USES_STD_STRING_VIEW. + +-#define ABSL_OPTION_USE_STD_STRING_VIEW 2 ++#define ABSL_OPTION_USE_STD_STRING_VIEW 0 + + // ABSL_OPTION_USE_STD_VARIANT + // +@@ -174,7 +174,7 @@ + // absl::variant is a typedef of std::variant, use the feature macro + // ABSL_USES_STD_VARIANT. + +-#define ABSL_OPTION_USE_STD_VARIANT 2 ++#define ABSL_OPTION_USE_STD_VARIANT 0 + + + // ABSL_OPTION_USE_INLINE_NAMESPACE +@@ -200,7 +200,7 @@ + // allowed. + + #define ABSL_OPTION_USE_INLINE_NAMESPACE 1 +-#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20230125 ++#define ABSL_OPTION_INLINE_NAMESPACE_NAME debian4 + + // ABSL_OPTION_HARDENED + // +@@ -227,6 +227,6 @@ + // checks enabled by this option may abort the program in a different way and + // log additional information when `NDEBUG` is not defined. + +-#define ABSL_OPTION_HARDENED 0 ++#define ABSL_OPTION_HARDENED 1 + + #endif // ABSL_BASE_OPTIONS_H_ diff --git a/debian/patches/cordz-info-statistics-test.diff b/debian/patches/cordz-info-statistics-test.diff new file mode 100644 index 00000000..646133a1 --- /dev/null +++ b/debian/patches/cordz-info-statistics-test.diff @@ -0,0 +1,11 @@ +--- a/absl/strings/internal/cordz_info_statistics_test.cc ++++ b/absl/strings/internal/cordz_info_statistics_test.cc +@@ -468,6 +468,8 @@ + } + + TEST(CordzInfoStatisticsTest, ThreadSafety) { ++ GTEST_SKIP() << "Skipping test; see https://bugs.debian.org/1018804"; ++ + Notification stop; + static constexpr int kNumThreads = 8; + int64_t sampled_node_count = 0; diff --git a/debian/patches/cpu-features.diff b/debian/patches/cpu-features.diff new file mode 100644 index 00000000..2f462e39 --- /dev/null +++ b/debian/patches/cpu-features.diff @@ -0,0 +1,55 @@ +From: Benjamin Barenblat <bbaren@google.com> +Subject: Canonicalize supported CPU feature set +Forwarded: not-needed + +Explicitly set supported CPU features. + + - Disable Intel SSE and SSE2 on i386, since Debian supports some i386 + processors without those extensions. Keep them enabled on amd64, since all + amd64 processors have them. + + - Disable Intel SSSE3 entirely, since no i386 processor supports it and Debian + supports amd64 processors without it. + + - Disable NEON on armel and armhf, since no armel processor supports NEON and + Debian supports some armhf processors without it. Keep it enabled on arm64, + since all arm64 processors have it. + +--- a/absl/base/config.h ++++ b/absl/base/config.h +@@ -887,7 +887,7 @@ + // which architectures support the various x86 instruction sets. + #ifdef ABSL_INTERNAL_HAVE_SSE + #error ABSL_INTERNAL_HAVE_SSE cannot be directly set +-#elif defined(__SSE__) ++#elif defined(__x86_64__) + #define ABSL_INTERNAL_HAVE_SSE 1 + #elif defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1) + // MSVC only defines _M_IX86_FP for x86 32-bit code, and _M_IX86_FP >= 1 +@@ -902,7 +902,7 @@ + // which architectures support the various x86 instruction sets. + #ifdef ABSL_INTERNAL_HAVE_SSE2 + #error ABSL_INTERNAL_HAVE_SSE2 cannot be directly set +-#elif defined(__SSE2__) ++#elif defined(__x86_64__) + #define ABSL_INTERNAL_HAVE_SSE2 1 + #elif defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2) + // MSVC only defines _M_IX86_FP for x86 32-bit code, and _M_IX86_FP >= 2 +@@ -923,8 +923,6 @@ + // by the CPU. + #ifdef ABSL_INTERNAL_HAVE_SSSE3 + #error ABSL_INTERNAL_HAVE_SSSE3 cannot be directly set +-#elif defined(__SSSE3__) +-#define ABSL_INTERNAL_HAVE_SSSE3 1 + #endif + + // ABSL_INTERNAL_HAVE_ARM_NEON is used for compile-time detection of NEON (ARM +@@ -936,7 +934,7 @@ + // https://llvm.org/docs/CompileCudaWithLLVM.html#detecting-clang-vs-nvcc-from-code + #ifdef ABSL_INTERNAL_HAVE_ARM_NEON + #error ABSL_INTERNAL_HAVE_ARM_NEON cannot be directly set +-#elif defined(__ARM_NEON) && !defined(__CUDA_ARCH__) ++#elif defined(__aarch64__) + #define ABSL_INTERNAL_HAVE_ARM_NEON 1 + #endif + diff --git a/debian/patches/empty-flags-library.diff b/debian/patches/empty-flags-library.diff new file mode 100644 index 00000000..8c26a6d7 --- /dev/null +++ b/debian/patches/empty-flags-library.diff @@ -0,0 +1,19 @@ +From: Benjamin Barenblat <bbaren@google.com> +Subject: Eliminate libabsl_flags.so and libabsl_flags.a +Forwarded: not-needed + +The libabsl_flags library only contains code when compiling with MSVC, which +Debian doesn't use. Skip compiling absl/flags/flag.cc, and make the Abseil flags +library header-only. + +--- a/absl/flags/CMakeLists.txt ++++ b/absl/flags/CMakeLists.txt +@@ -199,8 +199,6 @@ + absl_cc_library( + NAME + flags +- SRCS +- "flag.cc" + HDRS + "declare.h" + "flag.h" diff --git a/debian/patches/latomic.diff b/debian/patches/latomic.diff new file mode 100644 index 00000000..92b4f30c --- /dev/null +++ b/debian/patches/latomic.diff @@ -0,0 +1,20 @@ +From: Benjamin Barenblat <bbaren@google.com> +Subject: Use libatomic if necessary +Bug-Debian: https://bugs.debian.org/973492 + +On some architectures, notably armel, Abseil needs symbols defined in +libatomic. Abseil does not currently have a well-developed system to +declare external library dependencies, so just have the linker determine +if anything needs libatomic and add the DT_NEEDED entry where necessary. + +--- a/absl/copts/AbseilConfigureCopts.cmake ++++ b/absl/copts/AbseilConfigureCopts.cmake +@@ -93,4 +93,8 @@ + set(ABSL_TEST_COPTS "") + endif() + ++list(APPEND ABSL_DEFAULT_LINKOPTS ++ "-Wl,--push-state,--as-needed" "-latomic" "-Wl,--pop-state" ++) ++ + set(ABSL_CXX_STANDARD "${CMAKE_CXX_STANDARD}") diff --git a/debian/patches/pkg-config-directives.diff b/debian/patches/pkg-config-directives.diff new file mode 100644 index 00000000..726d6aec --- /dev/null +++ b/debian/patches/pkg-config-directives.diff @@ -0,0 +1,21 @@ +From: Benjamin Barenblat <bbaren@google.com> +Subject: Do not propagate -Wno-... flags into pkg-config files +Forwarded: not-needed + +Lintian doesn't like any -W flags in pkg-config files, even if those flags +disable warnings. + +--- a/CMake/AbseilHelpers.cmake ++++ b/CMake/AbseilHelpers.cmake +@@ -187,10 +187,7 @@ + endif() + endforeach() + foreach(cflag ${ABSL_CC_LIB_COPTS}) +- if(${cflag} MATCHES "^(-Wno|/wd)") +- # These flags are needed to suppress warnings that might fire in our headers. +- set(PC_CFLAGS "${PC_CFLAGS} ${cflag}") +- elseif(${cflag} MATCHES "^(-W|/w[1234eo])") ++ if(${cflag} MATCHES "^(-W|/w[1234eo])") + # Don't impose our warnings on others. + elseif(${cflag} MATCHES "^-m") + # Don't impose CPU instruction requirements on others, as diff --git a/debian/patches/series b/debian/patches/series new file mode 100644 index 00000000..000d6558 --- /dev/null +++ b/debian/patches/series @@ -0,0 +1,8 @@ +configure.diff +cpu-features.diff +latomic.diff +empty-flags-library.diff +cordz-info-statistics-test.diff +pkg-config-directives.diff +split-hash-tests.diff +symbolize-ppc64.diff diff --git a/debian/patches/split-hash-tests.diff b/debian/patches/split-hash-tests.diff new file mode 100644 index 00000000..ae0d066f --- /dev/null +++ b/debian/patches/split-hash-tests.diff @@ -0,0 +1,677 @@ +From: Benjamin Barenblat <bbaren@google.com> +Subject: Split absl/hash/hash_test.cc into two files +Origin: backport, https://github.com/abseil/abseil-cpp/commit/c154d20abce2f1ae6bd35bd774313e351493219b + +hash_test.cc leans heavily on INSTANTIATE_TYPED_TEST_SUITE_P, which is quite +memory- and CPU-hungry. Split a few heavyweight tests into a new +hash_instantiated_test.cc, reducing peak RAM consumption (or, on multicore +systems, compilation time). + +--- a/absl/hash/BUILD.bazel ++++ b/absl/hash/BUILD.bazel +@@ -68,13 +68,17 @@ + + cc_test( + name = "hash_test", +- srcs = ["hash_test.cc"], ++ srcs = [ ++ "hash_test.cc", ++ "internal/hash_test.h", ++ ], + copts = ABSL_TEST_COPTS, + linkopts = ABSL_DEFAULT_LINKOPTS, + deps = [ + ":hash", + ":hash_testing", + ":spy_hash_state", ++ "//absl/base:config", + "//absl/base:core_headers", + "//absl/container:btree", + "//absl/container:flat_hash_map", +@@ -87,6 +91,27 @@ + "@com_google_googletest//:gtest_main", + ], + ) ++ ++cc_test( ++ name = "hash_instantiated_test", ++ srcs = [ ++ "hash_instantiated_test.cc", ++ "internal/hash_test.h", ++ ], ++ copts = ABSL_TEST_COPTS, ++ linkopts = ABSL_DEFAULT_LINKOPTS, ++ deps = [ ++ ":hash", ++ ":hash_testing", ++ "//absl/base:config", ++ "//absl/container:btree", ++ "//absl/container:flat_hash_map", ++ "//absl/container:flat_hash_set", ++ "//absl/container:node_hash_map", ++ "//absl/container:node_hash_set", ++ "@com_google_googletest//:gtest_main", ++ ], ++) + + cc_binary( + name = "hash_benchmark", +--- a/absl/hash/CMakeLists.txt ++++ b/absl/hash/CMakeLists.txt +@@ -64,6 +64,7 @@ + hash_test + SRCS + "hash_test.cc" ++ "internal/hash_test.h" + COPTS + ${ABSL_TEST_COPTS} + DEPS +@@ -82,6 +83,26 @@ + GTest::gmock_main + ) + ++absl_cc_test( ++ NAME ++ hash_instantiated_test ++ SRCS ++ "hash_test.cc" ++ "internal/hash_test.h" ++ COPTS ++ ${ABSL_TEST_COPTS} ++ DEPS ++ absl::hash ++ absl::hash_testing ++ absl::config ++ absl::btree ++ absl::flat_hash_map ++ absl::flat_hash_set ++ absl::node_hash_map ++ absl::node_hash_set ++ GTest::gtest_main ++) ++ + # Internal-only target, do not depend on directly. + # + # Note: Even though external code should not depend on this target +--- /dev/null ++++ b/absl/hash/hash_instantiated_test.cc +@@ -0,0 +1,224 @@ ++// Copyright 2018 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. ++ ++// This file contains a few select absl::Hash tests that, due to their reliance ++// on INSTANTIATE_TYPED_TEST_SUITE_P, require a large amount of memory to ++// compile. Put new tests in hash_test.cc, not this file. ++ ++#include "absl/hash/hash.h" ++ ++#include <stddef.h> ++ ++#include <algorithm> ++#include <deque> ++#include <forward_list> ++#include <initializer_list> ++#include <list> ++#include <map> ++#include <set> ++#include <string> ++#include <type_traits> ++#include <unordered_map> ++#include <unordered_set> ++#include <utility> ++#include <vector> ++ ++#include "gtest/gtest.h" ++#include "absl/container/btree_map.h" ++#include "absl/container/btree_set.h" ++#include "absl/container/flat_hash_map.h" ++#include "absl/container/flat_hash_set.h" ++#include "absl/container/node_hash_map.h" ++#include "absl/container/node_hash_set.h" ++#include "absl/hash/hash_testing.h" ++#include "absl/hash/internal/hash_test.h" ++ ++namespace { ++ ++using ::absl::hash_test_internal::is_hashable; ++using ::absl::hash_test_internal::TypeErasedContainer; ++ ++// Dummy type with unordered equality and hashing semantics. This preserves ++// input order internally, and is used below to ensure we get test coverage ++// for equal sequences with different iteraton orders. ++template <typename T> ++class UnorderedSequence { ++ public: ++ UnorderedSequence() = default; ++ template <typename TT> ++ UnorderedSequence(std::initializer_list<TT> l) ++ : values_(l.begin(), l.end()) {} ++ template <typename ForwardIterator, ++ typename std::enable_if<!std::is_integral<ForwardIterator>::value, ++ bool>::type = true> ++ UnorderedSequence(ForwardIterator begin, ForwardIterator end) ++ : values_(begin, end) {} ++ // one-argument constructor of value type T, to appease older toolchains that ++ // get confused by one-element initializer lists in some contexts ++ explicit UnorderedSequence(const T& v) : values_(&v, &v + 1) {} ++ ++ using value_type = T; ++ ++ size_t size() const { return values_.size(); } ++ typename std::vector<T>::const_iterator begin() const { ++ return values_.begin(); ++ } ++ typename std::vector<T>::const_iterator end() const { return values_.end(); } ++ ++ friend bool operator==(const UnorderedSequence& lhs, ++ const UnorderedSequence& rhs) { ++ return lhs.size() == rhs.size() && ++ std::is_permutation(lhs.begin(), lhs.end(), rhs.begin()); ++ } ++ friend bool operator!=(const UnorderedSequence& lhs, ++ const UnorderedSequence& rhs) { ++ return !(lhs == rhs); ++ } ++ template <typename H> ++ friend H AbslHashValue(H h, const UnorderedSequence& u) { ++ return H::combine(H::combine_unordered(std::move(h), u.begin(), u.end()), ++ u.size()); ++ } ++ ++ private: ++ std::vector<T> values_; ++}; ++ ++template <typename T> ++class HashValueSequenceTest : public testing::Test {}; ++TYPED_TEST_SUITE_P(HashValueSequenceTest); ++ ++TYPED_TEST_P(HashValueSequenceTest, BasicUsage) { ++ EXPECT_TRUE((is_hashable<TypeParam>::value)); ++ ++ using IntType = typename TypeParam::value_type; ++ auto a = static_cast<IntType>(0); ++ auto b = static_cast<IntType>(23); ++ auto c = static_cast<IntType>(42); ++ ++ std::vector<TypeParam> exemplars = { ++ TypeParam(), TypeParam(), TypeParam{a, b, c}, ++ TypeParam{a, c, b}, TypeParam{c, a, b}, TypeParam{a}, ++ TypeParam{a, a}, TypeParam{a, a, a}, TypeParam{a, a, b}, ++ TypeParam{a, b, a}, TypeParam{b, a, a}, TypeParam{a, b}, ++ TypeParam{b, c}}; ++ EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); ++} ++ ++REGISTER_TYPED_TEST_SUITE_P(HashValueSequenceTest, BasicUsage); ++using IntSequenceTypes = testing::Types< ++ std::deque<int>, std::forward_list<int>, std::list<int>, std::vector<int>, ++ std::vector<bool>, TypeErasedContainer<std::vector<int>>, std::set<int>, ++ std::multiset<int>, UnorderedSequence<int>, ++ TypeErasedContainer<UnorderedSequence<int>>, std::unordered_set<int>, ++ std::unordered_multiset<int>, absl::flat_hash_set<int>, ++ absl::node_hash_set<int>, absl::btree_set<int>>; ++INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueSequenceTest, IntSequenceTypes); ++ ++template <typename T> ++class HashValueNestedSequenceTest : public testing::Test {}; ++TYPED_TEST_SUITE_P(HashValueNestedSequenceTest); ++ ++TYPED_TEST_P(HashValueNestedSequenceTest, BasicUsage) { ++ using T = TypeParam; ++ using V = typename T::value_type; ++ std::vector<T> exemplars = { ++ // empty case ++ T{}, ++ // sets of empty sets ++ T{V{}}, T{V{}, V{}}, T{V{}, V{}, V{}}, ++ // multisets of different values ++ T{V{1}}, T{V{1, 1}, V{1, 1}}, T{V{1, 1, 1}, V{1, 1, 1}, V{1, 1, 1}}, ++ // various orderings of same nested sets ++ T{V{}, V{1, 2}}, T{V{}, V{2, 1}}, T{V{1, 2}, V{}}, T{V{2, 1}, V{}}, ++ // various orderings of various nested sets, case 2 ++ T{V{1, 2}, V{3, 4}}, T{V{1, 2}, V{4, 3}}, T{V{1, 3}, V{2, 4}}, ++ T{V{1, 3}, V{4, 2}}, T{V{1, 4}, V{2, 3}}, T{V{1, 4}, V{3, 2}}, ++ T{V{2, 3}, V{1, 4}}, T{V{2, 3}, V{4, 1}}, T{V{2, 4}, V{1, 3}}, ++ T{V{2, 4}, V{3, 1}}, T{V{3, 4}, V{1, 2}}, T{V{3, 4}, V{2, 1}}}; ++ EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); ++} ++ ++REGISTER_TYPED_TEST_SUITE_P(HashValueNestedSequenceTest, BasicUsage); ++template <typename T> ++using TypeErasedSet = TypeErasedContainer<UnorderedSequence<T>>; ++ ++using NestedIntSequenceTypes = testing::Types< ++ std::vector<std::vector<int>>, std::vector<UnorderedSequence<int>>, ++ std::vector<TypeErasedSet<int>>, UnorderedSequence<std::vector<int>>, ++ UnorderedSequence<UnorderedSequence<int>>, ++ UnorderedSequence<TypeErasedSet<int>>, TypeErasedSet<std::vector<int>>, ++ TypeErasedSet<UnorderedSequence<int>>, TypeErasedSet<TypeErasedSet<int>>>; ++INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueNestedSequenceTest, ++ NestedIntSequenceTypes); ++ ++template <typename T> ++class HashValueAssociativeMapTest : public testing::Test {}; ++TYPED_TEST_SUITE_P(HashValueAssociativeMapTest); ++ ++TYPED_TEST_P(HashValueAssociativeMapTest, BasicUsage) { ++ using M = TypeParam; ++ using V = typename M::value_type; ++ std::vector<M> exemplars{M{}, ++ M{V{0, "foo"}}, ++ M{V{1, "foo"}}, ++ M{V{0, "bar"}}, ++ M{V{1, "bar"}}, ++ M{V{0, "foo"}, V{42, "bar"}}, ++ M{V{42, "bar"}, V{0, "foo"}}, ++ M{V{1, "foo"}, V{42, "bar"}}, ++ M{V{1, "foo"}, V{43, "bar"}}, ++ M{V{1, "foo"}, V{43, "baz"}}}; ++ EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); ++} ++ ++REGISTER_TYPED_TEST_SUITE_P(HashValueAssociativeMapTest, BasicUsage); ++using AssociativeMapTypes = testing::Types< ++ std::map<int, std::string>, std::unordered_map<int, std::string>, ++ absl::flat_hash_map<int, std::string>, ++ absl::node_hash_map<int, std::string>, absl::btree_map<int, std::string>, ++ UnorderedSequence<std::pair<const int, std::string>>>; ++INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueAssociativeMapTest, ++ AssociativeMapTypes); ++ ++template <typename T> ++class HashValueAssociativeMultimapTest : public testing::Test {}; ++TYPED_TEST_SUITE_P(HashValueAssociativeMultimapTest); ++ ++TYPED_TEST_P(HashValueAssociativeMultimapTest, BasicUsage) { ++ using MM = TypeParam; ++ using V = typename MM::value_type; ++ std::vector<MM> exemplars{MM{}, ++ MM{V{0, "foo"}}, ++ MM{V{1, "foo"}}, ++ MM{V{0, "bar"}}, ++ MM{V{1, "bar"}}, ++ MM{V{0, "foo"}, V{0, "bar"}}, ++ MM{V{0, "bar"}, V{0, "foo"}}, ++ MM{V{0, "foo"}, V{42, "bar"}}, ++ MM{V{1, "foo"}, V{42, "bar"}}, ++ MM{V{1, "foo"}, V{1, "foo"}, V{43, "bar"}}, ++ MM{V{1, "foo"}, V{43, "bar"}, V{1, "foo"}}, ++ MM{V{1, "foo"}, V{43, "baz"}}}; ++ EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); ++} ++ ++REGISTER_TYPED_TEST_SUITE_P(HashValueAssociativeMultimapTest, BasicUsage); ++using AssociativeMultimapTypes = ++ testing::Types<std::multimap<int, std::string>, ++ std::unordered_multimap<int, std::string>>; ++INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueAssociativeMultimapTest, ++ AssociativeMultimapTypes); ++ ++} // namespace +--- a/absl/hash/hash_test.cc ++++ b/absl/hash/hash_test.cc +@@ -47,6 +47,7 @@ + #include "absl/container/node_hash_map.h" + #include "absl/container/node_hash_set.h" + #include "absl/hash/hash_testing.h" ++#include "absl/hash/internal/hash_test.h" + #include "absl/hash/internal/spy_hash_state.h" + #include "absl/meta/type_traits.h" + #include "absl/numeric/int128.h" +@@ -54,52 +55,9 @@ + + namespace { + +-// Utility wrapper of T for the purposes of testing the `AbslHash` type erasure +-// mechanism. `TypeErasedValue<T>` can be constructed with a `T`, and can +-// be compared and hashed. However, all hashing goes through the hashing +-// type-erasure framework. +-template <typename T> +-class TypeErasedValue { +- public: +- TypeErasedValue() = default; +- TypeErasedValue(const TypeErasedValue&) = default; +- TypeErasedValue(TypeErasedValue&&) = default; +- explicit TypeErasedValue(const T& n) : n_(n) {} +- +- template <typename H> +- friend H AbslHashValue(H hash_state, const TypeErasedValue& v) { +- v.HashValue(absl::HashState::Create(&hash_state)); +- return hash_state; +- } +- +- void HashValue(absl::HashState state) const { +- absl::HashState::combine(std::move(state), n_); +- } +- +- bool operator==(const TypeErasedValue& rhs) const { return n_ == rhs.n_; } +- bool operator!=(const TypeErasedValue& rhs) const { return !(*this == rhs); } +- +- private: +- T n_; +-}; +- +-// A TypeErasedValue refinement, for containers. It exposes the wrapped +-// `value_type` and is constructible from an initializer list. +-template <typename T> +-class TypeErasedContainer : public TypeErasedValue<T> { +- public: +- using value_type = typename T::value_type; +- TypeErasedContainer() = default; +- TypeErasedContainer(const TypeErasedContainer&) = default; +- TypeErasedContainer(TypeErasedContainer&&) = default; +- explicit TypeErasedContainer(const T& n) : TypeErasedValue<T>(n) {} +- TypeErasedContainer(std::initializer_list<value_type> init_list) +- : TypeErasedContainer(T(init_list.begin(), init_list.end())) {} +- // one-argument constructor of value type T, to appease older toolchains that +- // get confused by one-element initializer lists in some contexts +- explicit TypeErasedContainer(const value_type& v) +- : TypeErasedContainer(T(&v, &v + 1)) {} +-}; ++using ::absl::hash_test_internal::is_hashable; ++using ::absl::hash_test_internal::TypeErasedContainer; ++using ::absl::hash_test_internal::TypeErasedValue; + + template <typename T> + using TypeErasedVector = TypeErasedContainer<std::vector<T>>; +@@ -117,11 +75,6 @@ + return SpyHashState::combine(SpyHashState(), value); + } + +-// Helper trait to verify if T is hashable. We use absl::Hash's poison status to +-// detect it. +-template <typename T> +-using is_hashable = std::is_default_constructible<absl::Hash<T>>; +- + TYPED_TEST_P(HashValueIntTest, BasicUsage) { + EXPECT_TRUE((is_hashable<TypeParam>::value)); + +@@ -520,121 +473,6 @@ + std::bitset<kNumBits>(bit_strings[5].c_str())})); + } // namespace + +-// Dummy type with unordered equality and hashing semantics. This preserves +-// input order internally, and is used below to ensure we get test coverage +-// for equal sequences with different iteraton orders. +-template <typename T> +-class UnorderedSequence { +- public: +- UnorderedSequence() = default; +- template <typename TT> +- UnorderedSequence(std::initializer_list<TT> l) +- : values_(l.begin(), l.end()) {} +- template <typename ForwardIterator, +- typename std::enable_if<!std::is_integral<ForwardIterator>::value, +- bool>::type = true> +- UnorderedSequence(ForwardIterator begin, ForwardIterator end) +- : values_(begin, end) {} +- // one-argument constructor of value type T, to appease older toolchains that +- // get confused by one-element initializer lists in some contexts +- explicit UnorderedSequence(const T& v) : values_(&v, &v + 1) {} +- +- using value_type = T; +- +- size_t size() const { return values_.size(); } +- typename std::vector<T>::const_iterator begin() const { +- return values_.begin(); +- } +- typename std::vector<T>::const_iterator end() const { return values_.end(); } +- +- friend bool operator==(const UnorderedSequence& lhs, +- const UnorderedSequence& rhs) { +- return lhs.size() == rhs.size() && +- std::is_permutation(lhs.begin(), lhs.end(), rhs.begin()); +- } +- friend bool operator!=(const UnorderedSequence& lhs, +- const UnorderedSequence& rhs) { +- return !(lhs == rhs); +- } +- template <typename H> +- friend H AbslHashValue(H h, const UnorderedSequence& u) { +- return H::combine(H::combine_unordered(std::move(h), u.begin(), u.end()), +- u.size()); +- } +- +- private: +- std::vector<T> values_; +-}; +- +-template <typename T> +-class HashValueSequenceTest : public testing::Test { +-}; +-TYPED_TEST_SUITE_P(HashValueSequenceTest); +- +-TYPED_TEST_P(HashValueSequenceTest, BasicUsage) { +- EXPECT_TRUE((is_hashable<TypeParam>::value)); +- +- using IntType = typename TypeParam::value_type; +- auto a = static_cast<IntType>(0); +- auto b = static_cast<IntType>(23); +- auto c = static_cast<IntType>(42); +- +- std::vector<TypeParam> exemplars = { +- TypeParam(), TypeParam(), TypeParam{a, b, c}, +- TypeParam{a, c, b}, TypeParam{c, a, b}, TypeParam{a}, +- TypeParam{a, a}, TypeParam{a, a, a}, TypeParam{a, a, b}, +- TypeParam{a, b, a}, TypeParam{b, a, a}, TypeParam{a, b}, +- TypeParam{b, c}}; +- EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); +-} +- +-REGISTER_TYPED_TEST_SUITE_P(HashValueSequenceTest, BasicUsage); +-using IntSequenceTypes = testing::Types< +- std::deque<int>, std::forward_list<int>, std::list<int>, std::vector<int>, +- std::vector<bool>, TypeErasedContainer<std::vector<int>>, std::set<int>, +- std::multiset<int>, UnorderedSequence<int>, +- TypeErasedContainer<UnorderedSequence<int>>, std::unordered_set<int>, +- std::unordered_multiset<int>, absl::flat_hash_set<int>, +- absl::node_hash_set<int>, absl::btree_set<int>>; +-INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueSequenceTest, IntSequenceTypes); +- +-template <typename T> +-class HashValueNestedSequenceTest : public testing::Test {}; +-TYPED_TEST_SUITE_P(HashValueNestedSequenceTest); +- +-TYPED_TEST_P(HashValueNestedSequenceTest, BasicUsage) { +- using T = TypeParam; +- using V = typename T::value_type; +- std::vector<T> exemplars = { +- // empty case +- T{}, +- // sets of empty sets +- T{V{}}, T{V{}, V{}}, T{V{}, V{}, V{}}, +- // multisets of different values +- T{V{1}}, T{V{1, 1}, V{1, 1}}, T{V{1, 1, 1}, V{1, 1, 1}, V{1, 1, 1}}, +- // various orderings of same nested sets +- T{V{}, V{1, 2}}, T{V{}, V{2, 1}}, T{V{1, 2}, V{}}, T{V{2, 1}, V{}}, +- // various orderings of various nested sets, case 2 +- T{V{1, 2}, V{3, 4}}, T{V{1, 2}, V{4, 3}}, T{V{1, 3}, V{2, 4}}, +- T{V{1, 3}, V{4, 2}}, T{V{1, 4}, V{2, 3}}, T{V{1, 4}, V{3, 2}}, +- T{V{2, 3}, V{1, 4}}, T{V{2, 3}, V{4, 1}}, T{V{2, 4}, V{1, 3}}, +- T{V{2, 4}, V{3, 1}}, T{V{3, 4}, V{1, 2}}, T{V{3, 4}, V{2, 1}}}; +- EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); +-} +- +-REGISTER_TYPED_TEST_SUITE_P(HashValueNestedSequenceTest, BasicUsage); +-template <typename T> +-using TypeErasedSet = TypeErasedContainer<UnorderedSequence<T>>; +- +-using NestedIntSequenceTypes = testing::Types< +- std::vector<std::vector<int>>, std::vector<UnorderedSequence<int>>, +- std::vector<TypeErasedSet<int>>, UnorderedSequence<std::vector<int>>, +- UnorderedSequence<UnorderedSequence<int>>, +- UnorderedSequence<TypeErasedSet<int>>, TypeErasedSet<std::vector<int>>, +- TypeErasedSet<UnorderedSequence<int>>, TypeErasedSet<TypeErasedSet<int>>>; +-INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueNestedSequenceTest, +- NestedIntSequenceTypes); +- + // Private type that only supports AbslHashValue to make sure our chosen hash + // implementation is recursive within absl::Hash. + // It uses std::abs() on the value to provide different bitwise representations +@@ -793,64 +631,6 @@ + #endif + } + +-template <typename T> +-class HashValueAssociativeMapTest : public testing::Test {}; +-TYPED_TEST_SUITE_P(HashValueAssociativeMapTest); +- +-TYPED_TEST_P(HashValueAssociativeMapTest, BasicUsage) { +- using M = TypeParam; +- using V = typename M::value_type; +- std::vector<M> exemplars{M{}, +- M{V{0, "foo"}}, +- M{V{1, "foo"}}, +- M{V{0, "bar"}}, +- M{V{1, "bar"}}, +- M{V{0, "foo"}, V{42, "bar"}}, +- M{V{42, "bar"}, V{0, "foo"}}, +- M{V{1, "foo"}, V{42, "bar"}}, +- M{V{1, "foo"}, V{43, "bar"}}, +- M{V{1, "foo"}, V{43, "baz"}}}; +- EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); +-} +- +-REGISTER_TYPED_TEST_SUITE_P(HashValueAssociativeMapTest, BasicUsage); +-using AssociativeMapTypes = testing::Types< +- std::map<int, std::string>, std::unordered_map<int, std::string>, +- absl::flat_hash_map<int, std::string>, +- absl::node_hash_map<int, std::string>, absl::btree_map<int, std::string>, +- UnorderedSequence<std::pair<const int, std::string>>>; +-INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueAssociativeMapTest, +- AssociativeMapTypes); +- +-template <typename T> +-class HashValueAssociativeMultimapTest : public testing::Test {}; +-TYPED_TEST_SUITE_P(HashValueAssociativeMultimapTest); +- +-TYPED_TEST_P(HashValueAssociativeMultimapTest, BasicUsage) { +- using MM = TypeParam; +- using V = typename MM::value_type; +- std::vector<MM> exemplars{MM{}, +- MM{V{0, "foo"}}, +- MM{V{1, "foo"}}, +- MM{V{0, "bar"}}, +- MM{V{1, "bar"}}, +- MM{V{0, "foo"}, V{0, "bar"}}, +- MM{V{0, "bar"}, V{0, "foo"}}, +- MM{V{0, "foo"}, V{42, "bar"}}, +- MM{V{1, "foo"}, V{42, "bar"}}, +- MM{V{1, "foo"}, V{1, "foo"}, V{43, "bar"}}, +- MM{V{1, "foo"}, V{43, "bar"}, V{1, "foo"}}, +- MM{V{1, "foo"}, V{43, "baz"}}}; +- EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(exemplars)); +-} +- +-REGISTER_TYPED_TEST_SUITE_P(HashValueAssociativeMultimapTest, BasicUsage); +-using AssociativeMultimapTypes = +- testing::Types<std::multimap<int, std::string>, +- std::unordered_multimap<int, std::string>>; +-INSTANTIATE_TYPED_TEST_SUITE_P(My, HashValueAssociativeMultimapTest, +- AssociativeMultimapTypes); +- + TEST(HashValueTest, ReferenceWrapper) { + EXPECT_TRUE(is_hashable<std::reference_wrapper<Private>>::value); + +--- /dev/null ++++ b/absl/hash/internal/hash_test.h +@@ -0,0 +1,87 @@ ++// Copyright 2023 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. ++ ++// Common code shared between absl/hash/hash_test.cc and ++// absl/hash/hash_instantiated_test.cc. ++ ++#ifndef ABSL_HASH_INTERNAL_HASH_TEST_H_ ++#define ABSL_HASH_INTERNAL_HASH_TEST_H_ ++ ++#include <type_traits> ++#include <utility> ++ ++#include "absl/base/config.h" ++#include "absl/hash/hash.h" ++ ++namespace absl { ++ABSL_NAMESPACE_BEGIN ++namespace hash_test_internal { ++ ++// Utility wrapper of T for the purposes of testing the `AbslHash` type erasure ++// mechanism. `TypeErasedValue<T>` can be constructed with a `T`, and can ++// be compared and hashed. However, all hashing goes through the hashing ++// type-erasure framework. ++template <typename T> ++class TypeErasedValue { ++ public: ++ TypeErasedValue() = default; ++ TypeErasedValue(const TypeErasedValue&) = default; ++ TypeErasedValue(TypeErasedValue&&) = default; ++ explicit TypeErasedValue(const T& n) : n_(n) {} ++ ++ template <typename H> ++ friend H AbslHashValue(H hash_state, const TypeErasedValue& v) { ++ v.HashValue(absl::HashState::Create(&hash_state)); ++ return hash_state; ++ } ++ ++ void HashValue(absl::HashState state) const { ++ absl::HashState::combine(std::move(state), n_); ++ } ++ ++ bool operator==(const TypeErasedValue& rhs) const { return n_ == rhs.n_; } ++ bool operator!=(const TypeErasedValue& rhs) const { return !(*this == rhs); } ++ ++ private: ++ T n_; ++}; ++ ++// A TypeErasedValue refinement, for containers. It exposes the wrapped ++// `value_type` and is constructible from an initializer list. ++template <typename T> ++class TypeErasedContainer : public TypeErasedValue<T> { ++ public: ++ using value_type = typename T::value_type; ++ TypeErasedContainer() = default; ++ TypeErasedContainer(const TypeErasedContainer&) = default; ++ TypeErasedContainer(TypeErasedContainer&&) = default; ++ explicit TypeErasedContainer(const T& n) : TypeErasedValue<T>(n) {} ++ TypeErasedContainer(std::initializer_list<value_type> init_list) ++ : TypeErasedContainer(T(init_list.begin(), init_list.end())) {} ++ // one-argument constructor of value type T, to appease older toolchains that ++ // get confused by one-element initializer lists in some contexts ++ explicit TypeErasedContainer(const value_type& v) ++ : TypeErasedContainer(T(&v, &v + 1)) {} ++}; ++ ++// Helper trait to verify if T is hashable. We use absl::Hash's poison status to ++// detect it. ++template <typename T> ++using is_hashable = std::is_default_constructible<absl::Hash<T>>; ++ ++} // namespace hash_test_internal ++ABSL_NAMESPACE_END ++} // namespace absl ++ ++#endif // ABSL_HASH_INTERNAL_HASH_TEST_H_ diff --git a/debian/patches/symbolize-ppc64.diff b/debian/patches/symbolize-ppc64.diff new file mode 100644 index 00000000..a11c27d4 --- /dev/null +++ b/debian/patches/symbolize-ppc64.diff @@ -0,0 +1,118 @@ +From: Benjamin Barenblat <bbaren@google.com> +Subject: Fix symbolization on PowerPC ELF v1 +Origin: backport, https://github.com/abseil/abseil-cpp/commit/372bfc86105728732fc115af46223d7a4e49f8d9 + +The big-endian PowerPC ELF ABI (ppc64 in Debian) relies on function descriptors +mapped in a non-executable segment. Make sure that segment is scanned during +symbolization. Also correct bounds computation for that segment. + +--- a/absl/debugging/symbolize_elf.inc ++++ b/absl/debugging/symbolize_elf.inc +@@ -648,8 +648,10 @@ + } + + // Return true if an address is inside a section. +-static bool InSection(const void *address, const ElfW(Shdr) * section) { +- const char *start = reinterpret_cast<const char *>(section->sh_addr); ++static bool InSection(const void *address, ptrdiff_t relocation, ++ const ElfW(Shdr) * section) { ++ const char *start = reinterpret_cast<const char *>( ++ section->sh_addr + static_cast<ElfW(Addr)>(relocation)); + size_t size = static_cast<size_t>(section->sh_size); + return start <= address && address < (start + size); + } +@@ -689,8 +691,8 @@ + // starting address. However, we do not always want to use the real + // starting address because we sometimes want to symbolize a function + // pointer into the .opd section, e.g. FindSymbol(&foo,...). +- const bool pc_in_opd = +- kPlatformUsesOPDSections && opd != nullptr && InSection(pc, opd); ++ const bool pc_in_opd = kPlatformUsesOPDSections && opd != nullptr && ++ InSection(pc, relocation, opd); + const bool deref_function_descriptor_pointer = + kPlatformUsesOPDSections && opd != nullptr && !pc_in_opd; + +@@ -730,7 +732,7 @@ + #endif + + if (deref_function_descriptor_pointer && +- InSection(original_start_address, opd)) { ++ InSection(original_start_address, /*relocation=*/0, opd)) { + // The opd section is mapped into memory. Just dereference + // start_address to get the first double word, which points to the + // function entry. +@@ -1326,7 +1328,7 @@ + const int phnum = obj->elf_header.e_phnum; + const int phentsize = obj->elf_header.e_phentsize; + auto phoff = static_cast<off_t>(obj->elf_header.e_phoff); +- size_t num_executable_load_segments = 0; ++ size_t num_interesting_load_segments = 0; + for (int j = 0; j < phnum; j++) { + ElfW(Phdr) phdr; + if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) { +@@ -1335,23 +1337,35 @@ + return false; + } + phoff += phentsize; +- constexpr int rx = PF_X | PF_R; +- if (phdr.p_type != PT_LOAD || (phdr.p_flags & rx) != rx) { +- // Not a LOAD segment, or not executable code. ++ ++#if defined(__powerpc__) && !(_CALL_ELF > 1) ++ // On the PowerPC ELF v1 ABI, function pointers actually point to function ++ // descriptors. These descriptors are stored in an .opd section, which is ++ // mapped read-only. We thus need to look at all readable segments, not ++ // just the executable ones. ++ constexpr int interesting = PF_R; ++#else ++ constexpr int interesting = PF_X | PF_R; ++#endif ++ ++ if (phdr.p_type != PT_LOAD ++ || (phdr.p_flags & interesting) != interesting) { ++ // Not a LOAD segment, not executable code, and not a function ++ // descriptor. + continue; + } +- if (num_executable_load_segments < obj->phdr.size()) { +- memcpy(&obj->phdr[num_executable_load_segments++], &phdr, sizeof(phdr)); ++ if (num_interesting_load_segments < obj->phdr.size()) { ++ memcpy(&obj->phdr[num_interesting_load_segments++], &phdr, sizeof(phdr)); + } else { + ABSL_RAW_LOG( +- WARNING, "%s: too many executable LOAD segments: %zu >= %zu", +- obj->filename, num_executable_load_segments, obj->phdr.size()); ++ WARNING, "%s: too many interesting LOAD segments: %zu >= %zu", ++ obj->filename, num_interesting_load_segments, obj->phdr.size()); + break; + } + } +- if (num_executable_load_segments == 0) { +- // This object has no "r-x" LOAD segments. That's unexpected. +- ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename); ++ if (num_interesting_load_segments == 0) { ++ // This object has no interesting LOAD segments. That's unexpected. ++ ABSL_RAW_LOG(WARNING, "%s: no interesting LOAD segments", obj->filename); + return false; + } + } +@@ -1379,8 +1393,8 @@ + // X in the file will have a start address of [true relocation]+X. + relocation = static_cast<ptrdiff_t>(start_addr - obj->offset); + +- // Note: some binaries have multiple "rx" LOAD segments. We must +- // find the right one. ++ // Note: some binaries have multiple LOAD segments that can contain ++ // function pointers. We must find the right one. + ElfW(Phdr) *phdr = nullptr; + for (size_t j = 0; j < obj->phdr.size(); j++) { + ElfW(Phdr) &p = obj->phdr[j]; +@@ -1390,7 +1404,7 @@ + ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type"); + break; + } +- if (pc < reinterpret_cast<void *>(start_addr + p.p_memsz)) { ++ if (pc < reinterpret_cast<void *>(start_addr + p.p_vaddr + p.p_memsz)) { + phdr = &p; + break; + } diff --git a/debian/rules b/debian/rules new file mode 100755 index 00000000..7f76c033 --- /dev/null +++ b/debian/rules @@ -0,0 +1,60 @@ +#!/usr/bin/make -f +# 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. + +include /usr/share/dpkg/architecture.mk + +export DEB_BUILD_MAINT_OPTIONS = hardening=+bindnow reproducible=+fixfilepath + +# Unit tests require more than 2 GB of RAM, so disable them on mipsel. +# +# Disable unit tests unconditionally if nocheck is set. +ifeq ($(DEB_HOST_ARCH),mipsel) +ABSL_RUN_TESTS=OFF +else ifneq ($(filter nocheck,$(DEB_BUILD_OPTIONS)),) +ABSL_RUN_TESTS=OFF +else +ABSL_RUN_TESTS=ON +endif + +# Debian's RISC-V builders don't have enough resources to run tests in parallel. +# See https://bugs.debian.org/1025221. +ifneq ($(filter $(DEB_HOST_ARCH),riscv64),) +ABSL_TEST_EXTRA_ARGS=--no-parallel +endif + +%: + dh $@ + +override_dh_auto_clean: + $(RM) -r $(CURDIR)/static + $(RM) -r $(CURDIR)/shared + +override_dh_auto_configure: + dh_auto_configure -Bstatic -- -DCMAKE_CXX_STANDARD=17 -DBUILD_SHARED_LIBS=OFF -DBUILD_TESTING=ON -DABSL_BUILD_TESTING=ON -DABSL_USE_GOOGLETEST_HEAD=OFF + dh_auto_configure -Bshared -- -DCMAKE_CXX_STANDARD=17 -DBUILD_SHARED_LIBS=ON + +override_dh_auto_build: + dh_auto_build -Bstatic + dh_auto_build -Bshared + +ifeq ($(ABSL_RUN_TESTS),ON) +override_dh_auto_test: + dh_auto_test -Bstatic $(ABSL_TEST_EXTRA_ARGS) +endif + +override_dh_auto_install: + dh_auto_install -Bstatic + dh_auto_install -Bshared + find debian/tmp -type d -empty -delete diff --git a/debian/source/format b/debian/source/format new file mode 100644 index 00000000..163aaf8d --- /dev/null +++ b/debian/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/debian/tests/bug1011294 b/debian/tests/bug1011294 new file mode 100755 index 00000000..302bcf73 --- /dev/null +++ b/debian/tests/bug1011294 @@ -0,0 +1,24 @@ +#!/bin/sh +# Copyright 2022 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. + +set -eu + +readonly TMP="$(mktemp -d)" +trap "rm -rf \"$TMP\"" EXIT +cd "$TMP" + +echo 'int main() {}' >noop.cc + +g++ -o noop noop.cc $(pkg-config --cflags absl_base) $(pkg-config --libs absl_base) diff --git a/debian/tests/cmake b/debian/tests/cmake new file mode 100755 index 00000000..43eb3408 --- /dev/null +++ b/debian/tests/cmake @@ -0,0 +1,45 @@ +#!/bin/sh -eu +# 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. + +readonly TMP="$(mktemp -d)" +trap "rm -rf \"$TMP\"" EXIT +cd "$TMP" + +cat >test.cc <<EOF +#include <absl/strings/numbers.h> + +int main(int argc, char* argv[]) { + int n; + if (!absl::SimpleAtoi(argv[1], &n)) { + return 1; + } + return n; +} +EOF + +cat >CMakeLists.txt <<EOF +cmake_minimum_required(VERSION 3.5) +project(test CXX) +set(CMAKE_CXX_STANDARD 17) +add_executable(test test.cc) +find_package(absl REQUIRED) +target_link_libraries(test absl::strings) +EOF + +mkdir build +cd build +cmake .. +make +./test 0 diff --git a/debian/tests/control b/debian/tests/control new file mode 100644 index 00000000..7bda87a7 --- /dev/null +++ b/debian/tests/control @@ -0,0 +1,25 @@ +# 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. + +Tests: smoke +Depends: @, g++, libgtest-dev + +Tests: cmake +Depends: @, cmake (>= 3.5), g++, make + +Tests: bug1011294 +Depends: @, g++, pkg-config + +Tests: upstream1407 +Depends: @, g++, libgmock-dev diff --git a/debian/tests/smoke b/debian/tests/smoke new file mode 100755 index 00000000..7c4b66fa --- /dev/null +++ b/debian/tests/smoke @@ -0,0 +1,37 @@ +#!/bin/sh -eu +# 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. + +readonly TMP="$(mktemp -d)" +trap "rm -rf \"$TMP\"" EXIT +cd "$TMP" + +cat >smoke.cc <<EOF +#include <absl/strings/str_join.h> +#include <gtest/gtest.h> + +#include <vector> + +namespace { + +TEST(AbseilTest, StrJoinWorks) { + std::vector<std::string> v = {"foo", "bar", "baz"}; + EXPECT_EQ(absl::StrJoin(v, "-"), "foo-bar-baz"); +} + +} // namespace +EOF + +g++ -o smoke smoke.cc -labsl_strings -lgtest -lgtest_main -pthread +./smoke diff --git a/debian/tests/upstream1407 b/debian/tests/upstream1407 new file mode 100755 index 00000000..332fc947 --- /dev/null +++ b/debian/tests/upstream1407 @@ -0,0 +1,28 @@ +#!/bin/sh +# Copyright 2023 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. + +set -eu + +readonly TMP="$(mktemp -d)" +trap "rm -rf \"$TMP\"" EXIT +cd "$TMP" + +cat >scoped_mock_log_trial.cc <<EOF +#include <absl/log/scoped_mock_log.h> + +int main() { absl::ScopedMockLog scoped_mock_log; } +EOF + +g++ -o scoped_mock_log_trial scoped_mock_log_trial.cc -labsl_scoped_mock_log -labsl_log_entry -labsl_log_sink -labsl_log_internal_log_sink_set -labsl_raw_logging_internal -labsl_log_severity -labsl_strings -lgmock -lgtest diff --git a/debian/watch b/debian/watch new file mode 100644 index 00000000..e621a589 --- /dev/null +++ b/debian/watch @@ -0,0 +1,18 @@ +# 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. + +version=4 +opts="filenamemangle=s%(?:.*?)?v?(\d[\d.]*)\.tar\.gz%@PACKAGE@-$1.tar.gz%, uversionmangle=s/^/0~/" \ + https://github.com/abseil/abseil-cpp/releases \ + (?:.*?/)?v?(\d[\d.]*)\.tar\.gz |