Don't run benchmarks as part of gtest, it would only prove that the benchmarks
work but not show the results. It can take a long time.

Add parameterized testing, based on #1448 by Ruben Vorderman

Co-authored-by: Ruben Vorderman <r.h.p.vorderman@lumc.nl>

ports: Use memalign or _aligned_malloc, when available. Fallback to malloc

Using "_WIN32" to decide,
if the MSVC extensions _aligned_malloc / _aligned_free are available
is a bug that breaks other Compiler on Windows. (OpenWatcom as Example)

Regards ... Detlef

fix the url of the s390x actions worker patch

gaplib changed their patch name scheme with 1a5e012.

Fold a copy into the adler32 function for UPDATEWINDOW for neon

So a lot of alterations had to be done to make this not worse and
so far, it's not really better, either. I had to force inlining for
the adler routine, I had to remove the x4 load instruction otherwise
pipelining stalled, and I had to use restrict pointers with a copy
idiom for GCC to inline a copy routine for the tail.

Still, we see a small benefit in benchmarks, particularly when done
with size of our window or larger. There's also an added benefit that
this will fix #1824.

Fix incorrect declaration of FORCE_SSE2

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Change flags to "-Werror=unguarded-availability", "-Werror=unguarded-availability-new" and add it to maybe affected symbol checking

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Restore support macOS prior 10.15

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Make Chorba configurable,and add a few missing header files to CMake config.
Add CI run without chorba enabled.

Use OPTIMAL_CMP instead of BRAID_W to test for optimal size for Chorba.

Clean up internal crc32 function handling.
Mark crc32_c and crc32_braid functions as internal, and remove prefix.
Reorder contents of generic_functions, and remove Z_INTERNAL hints from declarations.
Add test/benchmark output to indicate whether Chorba is used.

Replace DO1/DO8 macros

Move Chorba defines

Clean up crc32_braid.
- Rename N and W to BRAID_N and BRAID_W
- Remove override capabilities for BRAID_N and BRAID_W
- Fix formatting in crc32_braid_tbl.h
- Make makecrct not rely on crc32_braid_p.h

Added --installnamedir

implement chorba algorithm

Provide --without-acle/-DWITH_ACLE options for backward compatibility

Use -Wa,-march with older ARM toolchains

Provide an inline asm fallback for the ARMv8 intrinsics

Rename most ACLE references to ARMv8

2.2.4 Release

Fix shift overflow in inflate and send_code.

Fix an unfortunate bug with Visual Studio 2015

Evidently this instruction, despite the intrinsic having a register operand,
is a memory-register instruction. There seems to be no alignment requirement
for the source operand. Because of this, compilers when not optimized are doing
the unaligned load and then dumping back to the stack to do the broadcasting load.
In doing this, MSVC seems to be dumping to the stack with an aligned move at an
unaligned address, causing a segfault.  GCC does not seem to make this mistake, as
it stashes to an aligned address.

If we're on Visual Studio 2015, let's just do the longer 9 cycle sequence of a 128
bit load followed by a vinserti128. This _should_ fix this (issue #1861).

Fix -Wmaybe-uninitialized warnings in benchmarks.

Add uncompress benchmark

s390x: Add workaround to install custom Clang 19.1.5 rpms to actions-runner
image in order to avoid the VX compiler bug in older clang versions.

Remove unused include directories

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Rename "arch/power/fallback_builtins.h" to avoid possible conflict with "fallback_builtins.h" in zlib-ng sources directory

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

[abicheck] Regenerate ABI files for zlib
* Generate using Ubuntu 24.04.1 LTS to fix mismatch in function signatures of gzseek() and gztell()

Disable CRC32-VX Extention for some Clang versions
We have to disable the CRC32-VX implementation for some Clang versions
(18 <= version < 19.1.2) that generate bad code for the IBM S390 VGFMA intrinsics.

Increase cmake workflow timeout

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Use Ubuntu 20.04 for PPC64LE tests due to broken qemu.

Use Ubuntu 22.04 for AARCH64 tests

It seems that qemu might be failing. Tests on Raspberry Pi 5 with Ubuntu 24.04
appear to work just fine.

Add missing compiler-rt libraries for Ubuntu 24. #1840

Ignore gcovr parser errors.

Don't pin gcovr version any longer. #1840

Use correct version of gcov for cross-compilers.

Use Ubuntu 24 crossbuild-essential packages.

Remove package qemu for Ubuntu 24. #1840

Upgrade CI from Clang-11 to Clang 15 for Ubuntu 24. #1840

Improve image/container rebuild script to work properly under cron.

Workaround error G6E97C40B

Warning as an error with GCC from Uubuntu 24.04:
```
/home/runner/work/dotnet_riscv/dotnet_riscv/runtime/src/native/external/zlib-ng/arch/riscv/riscv_features.c(25,33): error G6E97C40B: suggest parentheses around ‘&&’ within ‘||’ [-Wparentheses] [/home/runner/work/dotnet_riscv/dotnet_riscv/runtime/src/native/libs/build-native.proj]
```

cmake: disable LTO for some configure checks

Some of zlib-ng's configure tests define a function expecting it to be compiled but
don't call that function, or don't use its return value. This is risky with
LTO where the whole thing may be optimised out, which has happened before:
* https://github.com/zlib-ng/zlib-ng/issues/1616
* https://github.com/zlib-ng/zlib-ng/pull/1622
* https://gitlab.kitware.com/cmake/cmake/-/issues/26103

Closes: https://github.com/zlib-ng/zlib-ng/issues/1841

Force use of latest Windows SDK with 32-bit ARM support for release workflows

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

2.2.3 Release

Continued cleanup of old UNALIGNED_OK checks
- Remove obsolete checks
- Fix checks that are inconsistent
- Stop compiling compare256/longest_match variants that never gets called
- Improve how the generic compare256 functions are handled.
- Allow overriding OPTIMAL_CMP

This simplifies the code and avoids having a lot of code in the compiled library than can never get executed.

Rename functions to get rid of old and now misleading "unaligned" naming

Use GCC's may_alias attribute for unaligned memory access

Improved setting of OPTIMAL_CMP on ARM

Fix unaligned access in ACLE based crc32

This fixes a rightful complaint from the alignment sanitizer that we
alias memory in an unaligned fashion. A nice added bonus is that this
improves performance a tiny bit on the larger buffers, perhaps due to
loops that idiomatically decrement a count and increment a single buffer
pointer rather than the maze of conditional pointer reassignments.

While here, let's write a unit test just for this. Since this is the only
variant that accesses memory in a potentially unaligned fashion that doesn't
explicitly go byte by byte or use intrinsics that don't require alignment,
we'll enable it only for this function for now. Adding more tests later if
need be should be possible. For everything else not crc, we're relying on
ubsan to hopefully catch things by chance.

Update s390x actions-runner docker

Set OPTIMAL_CMP for 32-bit PowerPC

Fix "RLE" compression with big endian architectures

This was missed in #1831. The RLE methods compare a string of bytes
directly with itself to directly derive a simple run length encoding.
They use similar but not identical methods to compare256. This needs
a similar endianness check at compile time to know which compare bit
count to use (leading or trailing).

Make big endians first class citizens again

No longer do the big iron on yore which lack SIMD optimized loads need
to search strings a byte at a time like primitive machines of the vax
era. This guard here was mostly due to the fact that the string
comparison was searched with "count trailing zero", which assumes an
endianness.  We can just conditionally use leading zeros when on big
endian and stop using the extremely naive C implementation. This makes
things a tad bit faster.

adler32_rvv: Fix some overflow problems

There are currently some overflow problems in adler32_rvv
implementation, which can lead to wrong results for some input, and
these problems could be easily exhibited when running `git fsck` with
zlib-ng suitituting the system zlib on a big git repository.

These problems and the solutions are the following:

- When the input data is long enough, the v_buf32_accu can overflow too.
  Add it to the modulo code that happens per ~NMAX bytes.
- When the vector data is reduced to scalar ones, the resulting scalar
  value (and the proceeded length) may lead to the calculation of sum2
  to overflow. Add mod BASE to all these reductions and initial
  calculation of sum2.
- When the remaining data less than vl bytes, the code falls back to a
  scalar implementation; however the sum2 and alder2 values are just
  reduced from vectors and could be very big that makes sum2 overflows
  in the scalar code. Modulo them before the scalar code to prevent such
  overflow (because vl is surely quite smaller than NMAX).

Signed-off-by: Icenowy Zheng <uwu@icenowy.me>

Since we long ago make unaligned reads safe (by using memcpy or intrinsics),
it is time to replace the UNALIGNED_OK checks that have since really only been
used to select the optimal comparison sizes for the arch instead.

Fix typos (#1825)

added in-tree build artifacts to .gitignore

Revert "Since we long ago make unaligned reads safe (by using memcpy or intrinsics),"

This reverts commit 80fffd72f316df980bb15ea0daf06ba22e3583ec.
It was mistakenly pushed to develop instead of going through a PR and the appropriate reviews.

Since we long ago make unaligned reads safe (by using memcpy or intrinsics),
it is time to replace the UNALIGNED_OK checks that have since really only been
used to select the optimal comparison sizes for the arch instead.

Improve pipeling for AVX512 chunking

For reasons that aren't quite so clear, using the masked writes here
did not pipeline very well. Either setting up the mask stalled things
or masked moves have issues overlapping regular moves. Simply putting
the masked moves behind a branch that is rarely taken seemed to do the
trick in improving the ILP. While here, put masked loads behind the same
branch in case there were ever a hazard for overreading.

zbuild: Provide a fallback for "ALIGNED_(x)" for other compiler

Enable AVX2 functions to be built with BMI2 instructions

While these are technically different instructions, no such CPU exists
that has AVX2 that doesn't have BMI2. Enabling BMI2 allows us to
eliminate several flag stalls by having flagless versions of shifts, and
allows us to not clobber and move around GPRs so much in scalar code.
There's usually a sizeable benefit for enabling it. Since we're building
with BMI2 for AVX2 functions, let's also just make sure the CPU claims
to support it (just to cover our bases).

Address deprecated cmake version warning.

Use cmake_minimum_required(VERSION <min>...<policy_max>) syntax to set
the policy at the same time as the compatibile CMake version.

Bump codecov/codecov-action from 4 to 5

Bumps [codecov/codecov-action](https://github.com/codecov/codecov-action) from 4 to 5.
- [Release notes](https://github.com/codecov/codecov-action/releases)
- [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/codecov/codecov-action/compare/v4...v5)

---
updated-dependencies:
- dependency-name: codecov/codecov-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

Fix native detection of CRC instruction

It's unclear if raspberry pi OS's shipped GCC doesn't properly detect
ACLE or not (/proc/cpuinfo claims to support AES), but in any case, the
preprocessor macro for that flag is not defined with -march=native on a
raspberry pi 5. Unfortunately that means when built "WITH_NATIVE", we do
not get a fast CRC function.  The CRC32 preprocessor macro _IS_ defined,
and the auto detection when built without NATIVE support does properly
get dispatched to. Since we only need the scalar CRC32 and not the polynomial
stuff anyhow, let's make it be an || condition and not a && one.

Remove unused HAVE_CHUNKMEMSET_1 define

Fix casting warning/error in test_compress_bound.cc

Fixes the following error when building with msvc compiler
```
test_compress_bound.cc
D:\zlib-ng\test\test_compress_bound.cc(41,50): error C2220: the following warning is treated as an error
D:\zlib-ng\test\test_compress_bound.cc(41,50): warning C4267: 'argument': conversion from 'size_t' to 'unsigned long', possible loss of data
D:\zlib-ng\test\test_compress_bound.cc(43,68): warning C4267: 'argument': conversion from 'size_t' to 'unsigned long', possible loss of data
```

Force use of latest Windows SDK with 32-bit ARM support

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Make an AVX512 inflate fast with low cost masked writes

This takes advantage of the fact that on AVX512 architectures, masked
moves are incredibly cheap. There are many places where we have to
fallback to the safe C implementation of chunkcopy_safe because of the
assumed overwriting that occurs. We're to sidestep most of the branching
needed here by simply controlling the bounds of our writes with a mask.

Try to simply the inflate loop by collapsing most cases to chunksets

Make chunkset_avx2 half chunk aware

This gives us appreciable gains on a number of fronts.  The first being
we're inlining a pretty hot function that was getting dispatched to
regularly. Another is that we're able to do a safe lagged copy of a
distance that is smaller, so CHUNKCOPY gets its teeth back here for
smaller sizes, without having to do another dispatch to a function.

We're also now doing two overlapping writes at once and letting the CPU
do its store forwarding. This was an enhancement @dougallj had suggested
a while back.

Additionally, the "half chunk mag" here is fundamentally less
complicated because it doesn't require sythensizing cross lane permutes
with a blend operation, so we can optimistically do that first if the
len is small enough that a full 32 byte chunk doesn't make any sense.

Simplify avx2 chunkset a bit

Put length 16 in the length checking ladder and take care of it there
since it's also a simple case to handle. We kind of went out of our way
to pretend 128 bit vectors didn't exist when using avx2 but this can be
handled in a single instruction. Strangely the intrinsic uses vector
register operands but the instruction itself assumes a memory operand
for the source. This also means we don't have to handle this case in our
"GET_CHUNK_MAG" function.

Reorder variables in inflate functions to reduce padding holes
due to variable alignment requirements.

configure: add --mandir to override $mandir on command line.

configure: Fix linker flags for Haiku.

Reorder 'inflate_state' struct to improve cache-locality of variables
needed by inffast (from 6 cachelines to 1).
Also fill in some unnecessary holes.

Add variable 'wbufsize' to track window buffer including padding, to allow
the chunkset code to spill garbage data into the padding area if available.

Don't use 'dmax' and 'sane' variables unless their checks have been compiled in.

Compute the "safe" distance properly

The safe pointer that is computed is an exclusive, not inclusive bounds.
While we were probably rarely ever bit this, if ever, it still makes
sense to apply the limit, properly.

Explicitly set CMake policy 0169 to silence warning

The recommended `FetchContent_MakeAvailable()` is introduced in CMake
3.14 which is greater than `cmake_minimum_required()`.

CMake policy will effects subdirectories.

The `cmake_minimum_required(VERSION)` command implicitly calls
`cmake_policy(VERSION)`.

Closes https://github.com/zlib-ng/zlib-ng/issues/1788

Simplify chunking in the copy ladder here

As it turns out, trying to peel off the remainder with so many branches
caused the code size to inflate a bit too much that this function
wouldn't inline without some fairly aggressive optimization flags. Only
catching vector sized chunks here makes the loop body small enough and
having the byte by byte copy idiom at the bottom gives the compiler some
flexibility that it is likely to do something there.

Disable MSVC warning 4324 (struct padded due to alignment)

Force Visual C++ to treat source files as UTF-8.

Replace non-ascii characters to fix MSVC warning

[CI] Don't try to use macOS 11 as it's no longer supported.

Use target include instead of raw include

Fix overridde CMAKE_C_STANDARD, CMAKE_C_STANDARD_REQUIRED, CMAKE_C_EXTENSIONS. False value is allowed for CMAKE_C_STANDARD_REQUIRED and CMAKE_C_EXTENSIONS.

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Allow overridde CMAKE_CXX_STANDARD, CMAKE_CXX_STANDARD_REQUIRED, CMAKE_CXX_EXTENSIONS variables for tests and benchmarks.

Signed-off-by: Vladislav Shchapov <vladislav@shchapov.ru>

Fix build on aarch64 android.

When building with CMake toolchain provided by NDK, the ARCH variable is
not "aarch64", but "aarch64-none-linux-android26" (or similar). The
strict string match check causes the WITH_ARMV6 option to be enabled in
such a case. In result, arch/arm/slide_hash_armv6.c is compiled, which
is not intended to be used on aarch64, and fails.

Relax the check and assume aarch64 if the ARCH variable contains aarch64.

2.2.2 Release

Revert "Split chunkcopy_safe to allow the first part to be inlined more often."

This reverts commit 6b8efe78685926d89da0cf1c496c1022fc24f588.

New and improved chunkcopy_safe is coming soon.

Make use of unaligned loads on big endian in insert_string

Split chunkcopy_safe to allow the first part to be inlined more often.

[RISCV] Better run-time detection of RVV vector instruction support

Original version posted by @ncopa in #1705.

Fixed false positive HAVE_ARMV6_INTRIN value on old ARM platforms.

Don't use chunkunroll for inflateBack

If the output buffer and the window buffer are the same
memory allocation, we cannot make the assumptions that chunkunroll
does, that it is okay to overwrite the output buffer.

Address CR feedback

Fix new Windows SDK build break

Co-authored-by: Jan Kotas <jkotas@microsoft.com>

Enable warning C4242 and treat warnings as errors for Visual C++.