Fix build on ARM and gcc 4.x.

Fix the problem about rule to make target "zconf.h" on Arm platforms

If building zlib-ng with --acle option on Arm platforms, the building
process will stop in the meantime with the message "No rule to make
target zconf.h needed by crc32_acle.o".

This patch fixes the problem by including zconf.h or zconf-ng.h
according to the fact that whether ZLIB_COMPAT is defined or not in
crc32_acle.c.

Change-Id: Ib050c5b0e65d86210c8babdff5dbe670729fc63a

Signed-off-by: Richael Zhuang <richael.zhuang@arm.com>

Align in 16-byte boundary when UNALIGNED_OK is undefined.

[Issue #140] Use "/usr/bin/env bash" instead of /bin/sh.

[compat] Don't check for ZLIB_COMPAT
* ZLIB_COMPAT is always implied if using zlib.h
* Revert z_stream->adler to "unsigned long" to enforce correct alignment
  of struct members

[compat] Use unsigned long for size parameters of compress/compressBound/uncompress

Assume WITH_GZFILEOP is defined when compatibility mode is enabled.

Fix build problems about NEON (#149)

* Fix build problems about NEON on AArch64

NEON is enabled by default on armv8-a platforms, and so NEON related
objects should be included when the platform is armv8-a. Errors about
adler32_neon will occur when you run ./configure on armv8-a platforms
without --neon option, because zlib-ng uses --neon option to include
NEON related objects regardless of Arm architecture.
You will have similar issue when you build the project with cmake.

This patch fixes the problem by including NEON related objects when
the platform is armv8-a(including aarch64).

Use adler32_neon only when zlib-ng is configured with --neon (or
-DWITH_NEON=ON if using cmake), or else use the default adler32
no matter what Arm architecture is.

Signed-off-by: Richael Zhuang <richael.zhuang@arm.com>

Prefer memcpy and memcmp over direct memory read/comparisons. (#135)

* Prefer memcpy and memcmp over direct memory read/comparisons.

* Some platforms have alignment requirements and unaligned direct memory
  read/comparisons may result in undefined behaviour.
* Prefer memcpy and memcmp which are lowered to efficient assembly where
  possible.

Add option to disable test binaries ZLIB_ENABLE_TESTS

wrap crc32 in functable (#145)

* wrap crc32 in functable
* change internal crc32 api to use uint64_t rather than size_t for length

Use CMake to generate cmakein file (#146)

* Use CMake to generate cmakein file

Fix the bug in crc32_acle

On armv8-a platforms if --acle is enabled, zlib-ng will use crc32_acle
instead of the default crc32. However, in crc32_acle the __crc32b() is
used to calculate the crc result of two variables with types uint32_t
and uint64_t, which gives an error result.The correct function used
should be __crc32d().

Signed-off-by: Richael Zhuang <richael.zhuang@arm.com>

Fix dependency problem about cmake options

According to the content of CMakeLists.txt, if building with "-DZLIB_COMPAT=ON",
the value of WITH_GZFILEOP should be ON too. However, WITH_GZFILEOP is OFF
actually when you run "cmake .. -DZIB_COMPAT=ON", which will cause errors if you
use gzfile related functions.

This patch fixes the problem by adjusting the position of WITH_GZFILEOP
option.

Signed-off-by: Richael Zhuang <richael.zhuang@arm.com>

[ARM/AArch64] Allow disabling NEON support in adler32_stub.

Merge pull request #148 from Dead2/renamelib2

Rename library when compiled without --zlib-compat

Fix dynamic versioning of library

Adapt code to support PREFIX macros and update build scripts

Copy zconf.h.in to zconf-ng.h.in and add relevant processing in
configure and CMakeLists.txt

Add function prefix (zng_) to all exported functions to allow zlib-ng
to co-exist in an application that has been linked to something that
depends on stock zlib. Previously, that would cause random problems
since there is no way to guarantee what zlib version is being used
for each dynamically linked function.

Add the corresponding zlib-ng.h.

Tests, example and minigzip will not compile before they have been
adapted to use the correct functions as well.
Either duplicate them, so we have minigzip-ng.c for example, or add
compile-time detection in the source code.

Rename library based on zlib-compat setting
If zlib-compat is enabled, keep libz name.
If zlib-compat is disabled, use libz-ng name.

Add new .map file for -ng mode, with prefixed function names.

This commit only containes preparatory changes to
the central parts of the build system.

Fix .so library permissions on install, needs to be executable for packaging
systems such as RPM to pick them up as provided libraries.

Fix make distclean with non-standard make (#134)

Like mingw32-make

Merge pull request #131 from mtl1979/patch-1

Fix compiler warning and spelling mistake in zlib.h

Update zlib.h

Fix compiler warning and spelling mistake

Merge pull request #130 from mtl1979/sync

Sync with zlib development branch

Fix deflateEnd() to not report an error at start of raw deflate.

Avoid an undefined behavior of memcpy() in _tr_stored_block().

Allegedly the behavior of memcpy() is undefined if the source
pointer is NULL, even if the number of bytes to copy is zero.

Merge pull request #129 from mtl1979/patch-1

[arm] Fix insert_string_acle.c

Merge pull request #128 from jserv/develop

aarch64: Build fix

Merge pull request #127 from mtl1979/typefix

[Issue #126] Fix implicit cast from unsigned char to signed int.

Update insert_string_acle.c

Build fix.

aarch64: Build fix

[Issue #126] Fix implicit cast from unsigned char to int.

Merge pull request #115 from Dead2/hacknslash7

Merge Hacknslash7

Fix that s->prev is not used uninitialized in insert_string_*

Revert "x86: use TZCNT (#113)"

Reverted after objections to its inclusion.

This reverts commit a7271104bf9a2d82dc6a69090c12442eacd2fd71.

Make code an int in compress_block()

send_code() expects int instead of unsigned. Other procedures do pass
int.

configure: For Windows builds, add the CROSS_PREFIX to $RC and $STRIP.

zlib's original win32/Makefile.gcc did the same, but this was removed in
7d17132436431d5f62cf5089623073d72d07deb0. It is kind of essential for
cross-compiling a Win32 build on Linux, since `windres` most certainly
doesn't exist, and the regular `strip` may not be able to handle DLLs.

It should probably actually be something like

RC="${RC-${CROSS_PREFIX}windres}"

and

STRIP="${STRIP-${CROSS_PREFIX}strip}"

to be consistent with the assignments of $AR, $RANLIB and $NM, but this
didn't work for some reason.

ZLIB_COMPAT: add an extra 32 bits of padding in z_stream

zlib "stock" uses an "uLong" for zstream::adler, meaning 4 bytes in 64
bit bits. The padding makes zlib-ng a drop-in replacement for libz; without,
the deflateInit2_() function returns a version error when called from
dependents that were built against "stock" zlib.

Committed from host : Portia.local

various  CMake fixes:

- on Mac, builds can target 1 or more architectures that are not the host
  architecture. Pick the first from the list and ignore the others.
  A more complete implementation would warn if i386 and x86_64 builds are
  mixed via the compiler options.
- use CMake's compiler IDs to detect GCC and Clang (should be applied to
  icc too but I can't test)
- disable PCLMUL optimisation in 32bit Mac builds. It crashes and provides
  very little gain (to builds that are probably increasingly rare)

Committed from host : Portia.local

Apply trivial CMake fixes based on feedback from RJVB in issue #110

Make sure we don't export internal functions

x86: use TZCNT (#113)

x86: use TZCNT instruction
On processors that do not support TZCNT, the instruction byte encoding is executed as BSF.
TZCNT is faster on AMD than BSF.

Fix: wrong register for BMI1 bit (#112)

The BMI1 bit is in the ebx register and not in ecx.
See reference: https://software.intel.com/sites/default/files/article/405250/how-to-detect-new-instruction-support-in-the-4th-generation-intel-core-processor-family.pdf

Lazily initialize functable members. (#108)

- Split functableInit() function as separate functions for each functable member, so we don't need to initialize full functable in multiple places in the zlib-ng code, or to check for NULL on every invocation.
- Optimized function for each functable member is detected on first invocation and the functable item is updated for subsequent invocations.
- Remove NULL check in adler32() and adler32_z() as it is no longer needed.

- Add adler32 to functable
- Add missing call to functableinit from inflateinit
- Fix external direct calls to adler32 functions without calling functableinit

Style cleanup

Add missing functable.h dependencies in arch makefiles

Merge branch 'hacknslash7' of github.com:Dead2/zlib-ng into hacknslash7

ARM optimizations part 2 (#107)

*  add adler32_neon to main dependency checking and ARM/Windows Makefile
*  split non-optimized adler32 to adler32_c so we can test/compare both without recompiling.
*  add detection of default floating point ABI in gcc
    NOTE: This should avoid build error when gcc supports both ABIs but header for just one ABI is installed.

Make -warn use the pedantic parameter that makes warnings, not errors.

Style cleanup

Add a struct func_table and function functableInit.
The struct contains pointers to select functions to be used by the
rest of zlib, and the init function selects what functions will be
used depending on what optimizations has been compiled in and what
instruction-sets are available at runtime.

Tests done on a haswell cpu running minigzip -6 compression of a
40M file shows a 2.5% decrease in branches, and a 25-30% reduction
in iTLB-loads. The reduction i iTLB-loads is likely mostly due to
the inability to inline functions. This also causes a slight
performance regression of around 1%, this might still be worth it
to make it much easier to implement new optimized functions for
various architectures and instruction sets.

The performance penalty will get smaller for functions that get more
alternative implementations to choose from, since there is no need
to add more branches to every call of the function.
Today insert_string has 1 branch to choose insert_string_sse
or insert_string_c, but if we also add for example insert_string_sse4
then that would have needed another branch, and it would probably
at some point hinder effective inlining too.

Implementing NEON-ized Adler32 checksum (#102)

The checksum is calculated in the uncompressed PNG data and can be
made much faster by using SIMD. Tests in ARMv8 yielded an improvement
of about 3x (e.g. walltime was 350ms x 125ms for a 4096x4096 bytes
executed 30 times).

This yields an improvement in image decoding in Chromium around 18%
(see https://bugs.chromium.org/p/chromium/issues/detail?id=688601).

Neon-Optimized hash chain rebase. (#106)

* Neon-Optimized hash chain rebase.

Signed-off-by: Jun He <jun.he@arm.com>

CMakeLists.txt: Fix cross-compiling. (#104)

Merge pull request #93 from sebpop/develop

inflate: improve performance of memory copy operations

Merge pull request #88 from mtl1979/arm

Implement ACLE/NEON optimizations for ARM/AARCH64

CMakeLists.txt: We can't use check_c_source_runs() when cross-compiling.

Add initial support for ARM NEON vector instructions.

Optimize fill_window_c.

inflate: improve performance of memory copy operations

When memory copy operations happen byte by byte, the processors are unable to
fuse the loads and stores together because of aliasing issues.  This patch
clusters some of the memory copy operations in chunks of 16 and 8 bytes.

For byte memset, the compiler knows how to prepare the chunk to be stored.
When the memset pattern is larger than a byte, this patch builds the pattern for
chunk memset using the same technique as in Simon Hosie's patch
https://codereview.chromium.org/2722063002

This patch improves by 50% the performance of zlib decompression of a 50K PNG on
aarch64-linux and x86_64-linux when compiled with gcc-7 or llvm-5.

The number of executed instructions reported by valgrind --tool=cachegrind
on the decompression of a 50K PNG file on aarch64-linux:
- before the patch:
I   refs:      3,783,757,451
D   refs:      1,574,572,882  (869,116,630 rd   + 705,456,252 wr)

- with the patch:
I   refs:      2,391,899,214
D   refs:        899,359,836  (516,666,051 rd   + 382,693,785 wr)

The compression of a 260MB directory containing the code of llvm into a tar.gz
of 35MB and decompressing that with minigzip -d
on i7-4790K x86_64-linux, it takes 0.533s before the patch and 0.493s with the patch,
on Juno-r0 aarch64-linux A57, it takes 2.796s before the patch and 2.467s with the patch,
on Juno-r0 aarch64-linux A53, it takes 4.055s before the patch and 3.604s with the patch.

Add initial support for AARCH64.

Add support for ARM ACLE instructions.

Add ARM implementation of CTZL for Visual C++.

Inflate using wider loads and stores and a minimum of branches. (#95)

* Inflate using wider loads and stores.

In inflate_fast() the output pointer always has plenty of room to write.  This
means that so long as the target is capable, wide un-aligned loads and stores
can be used to transfer several bytes at once.

When the reference distance is too short simply unroll the data a little to
increase the distance.

Change-Id: I59854eb25d2b1e43561c8a2afaf9175bf10cf674

Let fill_window_c() and fill_window_sse() use insert_string().
And let the code assume MIN_MATCH is 3, so a bulk insert can be used.

deflate_medium: Make sure we have enough lookahead before trying to scan for matches.
* longest_match: Abort if match is in future

deflate_medium: Remove broken overlap test.

Don't pass unnecessary stream to fold_[1-4] and partial_fold.
Also fix some whitespace to make the code easier to read, and
better match the rest of the zlib-ng codebase.

Prevent potential division-by-zero in gzfwrite and gzfread.

Change so travis compiles with warnings enabled, when using configure.

Fix typos.

call memset for read after write dependences at distance 1

On a benchmark using zlib to decompress a PNG image this change shows a 20%
speedup.  It makes sense to special case distance = 1 of read after write
dependences because it is possible to replace the loop kernel with a memset
which is usually implemented in assembly in the libc, and because of the
frequency at which distance = 1 appears during the PNG decompression:

Distance Frequency
1 1009001
6 64500
9 29000
3 25500
144 14500
12 10000
15 3500
7 2000
24 1000
21 1000
18 1000
87 500
22 500
192 500

Update readme file, and add install instructions

CMakeLists.txt: Fix tests on MinGW.

Type cleanup...
* gz_statep -> gz_state *

CMakeLists.txt: Fix configuring under OS/X and MinGW
* Enable CMAKE_MACOSX_RPATH
* Fix detection of PCLMULQDQ
* Fix detection of off64_t

NOTE: If test for __off64_t succeeds, it should mean bug in our tests

minigzip: add support for deflate_stored.

test/example.c: Don't mix unsigned long and size_t.

Some tests were missing EXE suffix.

Let all platforms defining UNALIGNED_OK use the optimized put_short
implementation. Also change from pre-increment to post-increment to
prevent a double-store on non-x86 platforms.

Let all x86 and x86_64 archs use the new UPDATE_HASH implementation,
this improves compression performance and can often provide slightly
better compression.

Fix bug when level 0 used with Z_HUFFMAN or Z_RLE.

Compression level 0 requests no compression, using only stored
blocks. When Z_HUFFMAN or Z_RLE was used with level 0 (granted,
an odd choice, but permitted), the resulting blocks were mostly
fixed or dynamic. The reason is that deflate_stored() was not
being called in that case. The compressed data was valid, but it
was not what the application requested. This commit assures that
only stored blocks are emitted for compression level 0, regardless
of the strategy selected.

Clean up flushing override for level 1 if deflate_quick is enabled but sse4.2 not supported.

Fix 32bit compilation on x86_64 platform

Type cleanup...
* uInt -> unsigned int
* ulg -> unsigned long

Use insert_string instead of UPDATE_HASH to avoid double hashing.

Avoid hashing same memory location twice by truncating overlapping byte ranges,
it's speed optimization as the inner code also checks that previous hash value
is not same as new hash value. Essentially those two checks together makes the
compression a little more efficient as it can remember matches further apart.
As far as I remember from my tests, the secondary path was triggered only twice
in very long uncompressed file, but the gain in compression rate was still noticeable.

Fix leftover charf

Merge pull request #85 from mtl1979/cleanup

Cleanup configure and Makefile.in

quick_send_bits: variable 'code' is not used anymore.

Fix build with nmake.

Add --native flag to configure
* When using gcc, it will detect instruction sets available on host CPU

Merge branch 'hacknslash6' of github.com:Dead2/zlib-ng into hacknslash6

Use default osx version for travis build, seems travis has some capacity issues.

Makefile.in: Update rule to reset zconf.h.cmakein

Add dependency tracking for ARCH files.

Cleanup configure and makefiles