Remove code coverage libraries which introduce memory leak on exit.

Enable code coverage build only when code coverage report name specified.

[Benchmarks] Fix adler32/vmx benchmark not found under 32-bit PowerPC

Marginal improvement by pipelining loads on NEON

The ld1{4 reg} variant saves us instructions
and only adds 3 cycles of latency to load 3
more neon/asimd registers worth of data.

More than double adler32 performance with altivec

Bits of low hanging and high hanging fruit in this round of
optimization.  Altivec has a sum characters into 4 lanes of integers
instructions (intrinsic vec_sum4s) that seems basically made for this
algorithm.  Additionally, there's a similar multiply-accumulate routine
that takes two character vectors for input and outputs a vector of 4
ints for their respective adjacent sums.  This alone was a good amount
of the performance gains.

Additionally, the shifting by 4 was still done in the loop when it was
easy to roll outside of the loop and do only once.  This removed some
latency for a dependent operand to be ready.  We also unrolled the loop
with independent sums, though, this only seems to help for much larger
input sizes.

Additionally, we reduced feeding the two 16 bit halves of the sum simply
by packing them into an aligned allocation in the stack next to each
other.  Then, when loaded, we permute and shift the values to two
separate vector registers from the same input registers.  The separation
of these scalars probably could have been done in vector registers
through some tricks but we need them in scalar GPRs anyhow every time
they leave the loop so it was naturally better to keep those separate
before hitting the vectorized code.

For the horizontal addition, the code was modified to use a sequence of
shifts and adds to produce a vector sum in the first lane.  Then, the
much cheaper vec_ste was used to store the value into a general purpose
register rather than vec_extract.

Lastly, instead of doing the relatively expensive modulus in GPRs after
we perform the scalar operations to align all of the loads in the loop,
we can instead reduce "n" here for the first round to be n minus the
alignment offset.

Added sanitizer identification to CMake CI instance names.

Fixed S390X CI instance code coverage report names not unique.

Remove qemu-run variable which is already defined in the toolchain files. Only configure script would need this variable defined.

Fixed typo when undefined behavior sanitizer is not supported.

Remove unnecessary compiler specification from mingw configs.

Removed unused CMake includes in benchmark cmake.

Fixed wrong cpu check variable used for ARM in adler benchmarks.

IBM Z: Upgrade self-hosted builder to v2.287.1

[ARM] rename cmake/configure macros check_{acle,neon}_intrinsics to check_{acle,neon}_compiler_flag
* Currently these macros only check that the compiler flag(s) are supported, not that the compiler supports the actual intrinsics

[ARM] Use armv8-crc+simd when compiling ACLE code on toolchains that don't enable FPU by default.

Move _POSIX_C_SOURCE define before first stdlib.h include in zbuild.h for posix_memalign.

Remove zutil.h includes from many files to prevent zlib.h being included.

Move build basics to zbuild.h.

Added CMake status message when code coverage is enabled.

Use NATIVEFLAG in intrinsic checks that is added whenever it is enabled.

Added fallback macros for add_compile_options and add_link_options.

Use add_compile_options in cmake which sets both C and CXX flags.

It is necessary to break apart strings that contain multiple flags so they are processed by add_compile_options properly.

Use add_link_options in cmake sanitizer detection.

Use add_link_options in cmake code coverage detection.

Update CMake toolchains for alternative gcc/gcc++ names.
Remove compiler attribute in GHA when using CMake toolchain files.

[PowerPC] Default CPU to 7400 to enable VMX support in qemu-ppc

Use static keyword for vec_sumsu to prevent undefined reference error when g++ linking.

Intel compilers: update deprecated -wn to -Wall style

This removes warnings on every single target like:
icx: command line warning #10430: Unsupported command line options encountered
These options as listed are not supported.
For more information, use '-qnextgen-diag'.
option list:
        -w3

Signed-off-by: Michael Hirsch <michael@scivision.dev>

Fixed GCC warning about unused variable in longest_match.

match_tpl.h:47:13: warning: unused variable ‘scan_start’ [-Wunused-variable]
   47 |     uint8_t scan_start[8], scan_end[8];

Make cmake and configure release flags consistent

CMake sufficiently appends -DNDEBUG to the preprocessor macros when not
compiling with debug symbols.  This turns off debug level assertions and
has some other side effects.  As such, we should equally append this
define to the configure scripts' CFLAGS.

Remove unused fdopen define for MSVC.

Use pigz version 2.6 due to bug in NOTHREADS support.
https://github.com/madler/pigz/issues/97

Allow setting of version when building with pigz.

Move cpu feature variant callback typedefs to cpu_features header.

Use extern keyword in slide_hash function definitions.

Group together functable definitions that use deflate_state.

Use cpu_check_features in inflate and deflate.

Move cpu_feature includes out of zutil.h.

Use fixed width types in compare256 definition.

Fixed inadvertent breakage of CPUID usage

In removing the AVX512 "well-suited" flag, a second cpuid call that's
needed for feature detection was accidently removed.  This brings that
back.

Remove the "avx512_well_suited" cpu flag

Now that we have confirmation that the AVX512 variants so far have been
universally better on every capable CPU we've tested them on, there's no
sense in trying to maintain a whitelist.

Improvements to avx512 adler32 implementations

Now that better benchmarks are in place, it became apparent that masked
broadcast was _not_ faster and it's actually faster to use vmovd, as
suspected.  Additionally, for the VNNI variant, we've unlocked some
additional ILP by doing a second dot product in the loop to a different
running sum that gets recombined later.  This broke a data dependency
chain and allowed the IPC be ~2.75. The result is about a 40-50%
improvement in runtime.

Additionally, we've called the lesser SIMD sized variants if the input
is too small and they happen to be compiled in.  This helps for the
impossibly small input that still is large enough to be a vector length.
For size 16 and 32 inputs I was seeing something like sub 10 ns instead
of 50 ns.

Fixed AVX512-VNNI detection when compiling with ClangCl.

Remove crc32 and adler32 shared library tests which don't test anyting further than what is provided by crc32 static build or examplesh.

Rename test binaries with test_ prefix.

Fixed incorrect version of AVX specified for inflate chunk copying in feature list.

Merge feature list entries for crc32.

Clean up and remove bestcmp_t type for longest_match. Use 8 byte buffer (max int comparison size) and cast to integer type when making comparison.

Clean up crc32_fold structure and clearly define the size of the fold buffer.

Added adler32, compare256, crc32, and slide_hash benchmarks using Google Benchmark.

Co-authored-by: Adam Stylinski <kungfujesus06@gmail.com>

Change fuzzer binaries and solutions to prefix with fuzzer_.

Improved AVX2 adler32 performance

Did this by simply doing 32 bit horizontal sums and using the same sum
of absolute difference instructions as done in the SSE4 and AVX512_VNNI
versions.

Convert compare258 to compare256 and moved 2 byte check into deflate_quick. Prevents having multiple compare258 functions with 2 byte checks.

Merge crc32_little and crc32_big with preprocessor macros for each endian. Removed crc32_generic since it is not being used.

Remove unmaintained index markdown in arch/x86.

Remove unmaintained and out-dated DLL FAQ.

Rename x86 source files with instruction set version.

Remove unused COMPARE258 macro since longest_match only uses COMPARE256.

build: fix check for SSSE3 when using Emscripten

VPCLMULQDQ implementation for Intel's CRC32 folding.
Based on PR https://github.com/jtkukunas/zlib/pull/28.

Co-authored-by: Wangyang Guo <wangyang.guo@intel.com>

Added an SSE4 optimized adler32 checksum

This variant uses the lower number of cycles psadw insruction in place
of pmaddubsw for the running sum that does not need multiplication.

This allows this sum to be done independently, partially overlapping the
running "sum2" half of the checksum.  We also have moved the shift
outside of the loop, breaking a small data dependency chain. The code
also now does a vectorized horizontal sum without having to rebase to
the adler32 base, as NMAX is defined as the maximum number of scalar
sums that can be peformed, so we're actually safe in doing this without
upgrading to higher precision.  We can do a partial horizontal sum
because psadw only ends up accumulating 16 bit words in 2 vector lanes,
the other two can safely be assumed as 0.

Add SSE4.1 detection

Code leveraging this for the adler checksum is forthcoming

Use memcpy for unaligned reads.

Co-authored-by: Matija Skala <mskala@gmx.com>

Fixed missing pointers to functions when assigning to functable.

Clean up crc32 extern using #elif same as in crc32_stub.

Remove use_byfour compile time detection of the existence of four byte integer types since we are targeting newer systems.

Move generic crc32 assignment to else statement so it can be optimized away if use_byfour is true.

Don't assign C versions of compare258 and longest_match if we don't use them.

Have functioning avx512{,_vnni} adler32

The new adler32 checksum uses the VNNI instructions with appreciable
gains when possible. Otherwise, a pure avx512f variant exists which
still gives appreciable gains.

Check for err == Z_OK is always true in minideflate loops.

Fixed main function does not return value which may indicated unintended behavior.

Fixed part of conditional expression is always true since size is always greater than 0.

Fixed crc32 assembly not returning hash value to correct variable.

Don't build DLL sources if BUILD_SHARED_LIBS=OFF.

Fixed duplicate symbol zng_inflate_table and zng_inflate_copyright when BUILD_SHARED_LIBS=OFF.

Move stdint.h below zconf include to prevent unexpected characters warning on ClangCl.

Fixed incorrect flag used for SSE 4.2 support with ClangCl.

Fixed implicit declaration of _mm_extract_epi32 when compiling with ClangCl.

Fixed wrong alignment definition used when compiling with ClangCl.

Fix building shared tests
* Don't add non-PIC gz sources to shared executables if they are already included in shared library as PIC sources

Remove old win32 readme.

Remove double check for SSE4 in configure.

Fixed crc32_combine_gen declaration warning in zlib-ng API.

Upgrade version of GitHub checkout actions. #1078

Fix deflateBound and compressBound returning very small size estimates.
Remove workaround in switchlevels.c, so we do actual testing of this.
Use named defines instead of magic numbers where we can.

Avoid warning C4295 when using Visual C++ and maintainer warnings are enabled.

Remove gz_intmax implementation, since INT_MAX is always available in modern C implementations.

inttypes.h includes stdint.h, so only include one of them.

Added checks and comments to ensure that when using raw mode no checksumming takes place.

Added unit test to ensure that inflate with adler32 hash works on previously failed test case.

Don't overwrite adler32 hash with crc32 hash. #1066

Workaround for installation failure of wine32.

Made this work on 32 bit compilations

For some reason the movq instruction from a 128 bit register to a 64 bit
GPR is not supported in 32 bit code.  A simple workaround seems to be to
invoke movl if compiling with -m32.

Also addressing some style nits.

Have horizontal sum here, decent wins

Minor efficiency improvement

This now leverages the broadcasting instrinsics with an AND mask
to load up the registers.  Additionally, there's a minor efficiency
boost here by casting up to 64 bit precision (by means of register
aliasing) so that the modulo can be safely deferred until the write
back to the full sums.

The "write" back to the stack here is actually optimized out by GCC
and turned into a write directly to a 32 bit GPR for each of the 8
elements.  This much is not new, but now, since we don't have to do a
modulus with the BASE value, we can bypass 8 64 bit multiplications,
shifts, and subtractions while in those registers.

I tried to do a horizontal reduction sum on the 8 64 bit elements since
the vpextract* set of instructions aren't exactly low latency, however
to do this safely (no overflow) it requires 2 128 bit register extractions,
8 vpmovsxdq to bring the things up to 64 bit precision, some shuffles, more
128 bit extractions to get around the 128 bit lane requirement of the shuffles,
and finally a trip to a GPR and back to do the modulus on the scalar value.
This method could have been more efficient if there were an inexpensive 64 bit
horizontal addition instruction for AVX, but there isn't.

To test this, I wrote a pretty basic benchmark using Python's zlib bindings on
a huge set of random data, carefully timing only the checksum bits.  Invoking
perf stat from within the python process after the RNG shows a lower average
number of cycles to complete and a shorter runtime.

Use immediate variant of shift instruction

Since this is constant, anyway, we may as well use the variant that
doesn't add vector register pressure, has better ILP opportunities,
and has shorter instruction latency.

Reuse adler32_len_64 in adler32_c.

Fixed inflateGetDictionary length check may include bytes added by last call to inflate.

DFLTCC update for window optimization from Jim & Nathan

Stop relying on software and hardware inflate window formats being the
same and act the way we already do for deflate: provide and implement
window-related hooks.

Another possibility would be to use an in-line history buffer (by not
setting HBT_CIRCULAR), but this would require an extra memmove().

Also fix a couple corner cases in the software implementation of
inflateGetDictionary() and inflateSetDictionary().

Add back original version of inflate_fast for use with inflateBack.