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.

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

Merge pull request #86 from mtl1979/archclean

Replace remaining Z_NULL instances with NULL.

Fix only one half of a macro is executed in the correct side of the conditional,
causing the potential for hash corruption on calls to deflateParam() to change
level from 0 to something else.

Restructure travis config and add tests for osx.
Also start doing builds on ubuntu trusty (14.04) instead of precise (12.04).

Merge pull request #87 from mtl1979/cvefix

Fix so Travis doesn't unnecessarily fail on CVE tests without --zlib-compat.

Fix so Travis doesn't fail on CVE tests without --zlib-compat.

Replace remaining Z_NULL instances with NULL.

Merge pull request #84 from mtl1979/archclean

Cleanup architure-dependent code

Move Visual C++ workaround for CTZL to arch/x86.

MSVC: Use _tzcnt_u32() if available.

Move instruction set specific crc32 code to arch directories.

CMakeLists.txt: Cleanup.

Add support for internal attribute
The advantage of this over hidden is for example that the compiler can
safely assume that pointers to functions declared internal can never be
passed externally. This allows the compiler to consider optimizations
otherwise impossible.

Require cmake 2.8.4.
* Add duplicate check to add_intrinsics_option().

CMakeLists.txt: use check_c_source_runs instead of check_c_source_compiles
to try to avoid using intrinsics and an instruction set the compiler
knows but the host CPU doesn't support.

CMakeLists.txt : preliminary support for MSVC and ICC

- select the CMAKE_BUILD_TYPE "Release" by default if none has been set,
  to ensure maximum generic optimisation possible on the host platform
- add WITH_NATIVE_INSTRUCTIONS to build with -march=native or its equivalent
  option with other compilers (when we identify those alternatives)
- NATIVEFLAG (-march=native) will be used instead of -msseN/-mpclmul when
  defined/requested

TODO: discuss whether -msseN/-mpclmul should be used only for the files that
need them instead of globally, while NATIVEFLAG can (is supposed to) be used
globally.

CMakeLists.txt: better checking for Intel intrinsics.

The checks currently assume that instructions that build also execute.
This is not necessarily true: building with -msse4 on an AMD CPU (a C60)
that only has SSE4a leads to a crash in deflateInit2 when the compiler
apparently uses an unsupported instruction to set
s->hash_bits = memLevel + 7;

architecture checks translated from configure to cmake; initial draft

Initialize block_open state

On deflation context creation, initialize the block_open state to 0 to
ensure that no uninitialized values are used.

Add block_open state for deflate_quick

By storing whether or not a block has been opened (or terminated), the
static trees used for the block and the end block markers can be emitted
appropriately.

Fix Partial Symbol Generation for QUICK deflate

When using deflate_quick() in a streaming fashion and the output buffer
runs out of space while the input buffer still has data, deflate_quick()
would emit partial symbols. Force the deflate_quick() loop to terminate
for a flush before any further processing is done, returning to the main
deflate() routine to do its thing.

zlib 1.2.11

Permit immediate deflateParams changes before any deflate input.

This permits deflateParams to change the strategy and level right
after deflateInit, without having to wait until a header has been
written. The parameters can be changed immediately up until the
first deflate call that consumes any input data.

Update high water mark in deflate_stored.

This avoids unnecessary filling of bytes in the sliding window
buffer when switching from level zero to a non-zero level. This
also provides a consistent indication of deflate having taken
input for a later commit ...

Update vestigial comment from very old Info-ZIP deflate.

Fix deflate stored bug when pulling last block from window.

And some cosmetic cleanups.

Remove files to be installed before copying them in Makefile.in.
Based on upstream commit c7d77756d01210790b6d87442eba83dcc586a305

Fix bug in gzwrite.c that produced corrupt gzip files.

Fix bug in deflate_stored() for zero-length input.

Minor edits and clarifications of comments.

Avoid warnings on snprintf() return value.

zlib 1.2.9

Add crc32_z() and adler32_z() functions with size_t lengths.

Use a uniform approach for the largest value of an unsigned type.

Avoid some random compiler warnings on various platforms.

Fix typo from 'Add deflateGetDictionary() function' causing compilation failure.

Detect clang in cc version.

Add deflateGetDictionary() function.

Per request, but its utility is likely to be very limited. See the
comments in zlib.h.

Based on upstream ee7d7b5dda25c111e61e19ac7b476c26aa6f3020

No need to check for NULL argument to free().

Avoid use of DEBUG macro -- change to ZLIB_DEBUG.

Add gzfwrite(), duplicating the interface of fwrite().

Add gzfread(), duplicating the interface of fread().

Based on upstream commit 44dfd831d24f9b627ab666cf0973b0dce98fabba

Don't need to emit an empty fixed block when changing parameters.

gzsetparams() was using Z_PARTIAL_FLUSH when it could use Z_BLOCK
instead. This commit uses Z_BLOCK, which avoids emitting an
unnecessary ten bits into the stream.

Clean up gz* function return values.

In some cases the return values did not match the documentation,
or the documentation did not document all of the return values.
gzprintf() now consistently returns negative values on error,
which matches the behavior of the stdio fprintf() function.

Speed up deflation for level 0 (storing).

The previous code slid the window and the hash table and copied
every input byte three times in order to just write the data as
stored blocks with no compression. This commit minimizes sliding
and copying, especially for large input and output buffers.

Level 0 compression is now more than 20 times faster than before
the commit.

Most of the speedup is due to deferring hash table slides until
deflateParams() is called to change the compression level away
from 0. More speedup is due to copying directly from next_in to
next_out when the amounts of available input data and output space
permit it, avoiding the intermediate pending buffer. Additionally,
only the last 32K of the used input data is copied back to the
sliding window when large input buffers are provided.

Assure that deflateParams() will not switch functions mid-block.

This alters the specification in zlib.h, so that deflateParams()
will not change any parameters if there is not enough output space
in the event that a block is emitted in order to allow switching
the compression function.

Explicitly ignore a return value in gzwrite.c.

Add uncompress2() function, which returns the input size used.

Minor edits to the documentation in source file contents.

Fix crc corruption when using x86 PCLMULQDQ optimized crc.
We need to use crc_reset() instead of crc32() to do the reset.

Fix bugs in creating a very large gzip header.

Add --debug (-d) option to ./configure to define ZLIB_DEBUG.

Use memcpy for stored blocks.

This speeds up level 0 by about a factor of three, as compared to
the previous byte-at-a-time loop. We can do much better though. A
later commit avoids this copy for level 0 with large buffers,
instead copying directly from the input to the output. This commit
still speeds up storing incompressible data found when compressing
normally.

Fix some typos.

Make a noble effort at setting OS_CODE correctly.

Based on upstream commit ce12c5cd00628bf8f680c98123a369974d32df15

Original patch notes:
This updates the OS_CODE determination at compile time to match as
closely as possible the operating system mappings documented in
the PKWare APPNOTE.TXT version 6.3.4, section 4.4.2.2. That byte
in the gzip header is used by nobody for anything, as far as I can
tell. However we might as well try to set it appropriately.

Do a more thorough check of the state for every stream call.

This verifies that the state has been initialized, that it is the
expected type of state, deflate or inflate, and that at least the
first several bytes of the internal state have not been clobbered.

Document the rejection of 256-byte window requests in zlib.h.

Reject a window size of 256 bytes if not using the zlib wrapper.

There is a bug in deflate for windowBits == 8 (256-byte window).
As a result, zlib silently changes a request for 8 to a request
for 9 (512-byte window), and sets the zlib header accordingly so
that the decompressor knows to use a 512-byte window. However if
deflateInit2() is used for raw deflate or gzip streams, then there
is no indication that the request was not honored, and the
application might assume that it can use a 256-byte window when
decompressing. This commit returns an error if the user requests
a 256-byte window when using raw deflate or gzip encoding.

Avoid obfuscating use of default case in inftrees.c.

Move macro definition in deflate.c to where it is used.

This avoid defining a macro that is never used when not debugging.

Avoid recursive gzgetc() macro call.

Recursive macro calls are normally caught by the preprocessor and
avoided. This commit avoids the possibility of a problem entirely.