third_party/zlib/simd.patch - Issue 2079313002: Revert of Update Zlib to version 1.2.8

Unified Diff: third_party/zlib/simd.patch

Issue 2079313002: Revert of Update Zlib to version 1.2.8 (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: third_party/zlib/simd.patch

diff --git a/third_party/zlib/simd.patch b/third_party/zlib/simd.patch

deleted file mode 100644

index 5007b58f1adf3c32b9fb0b68b367be756e60c0f4..0000000000000000000000000000000000000000

--- a/third_party/zlib/simd.patch

+++ /dev/null

@@ -1,1198 +0,0 @@

-diff --git a/third_party/zlib/crc32.c b/third_party/zlib/crc32.c

-index 979a719..09228ed 100644

---- a/third_party/zlib/crc32.c

-+++ b/third_party/zlib/crc32.c

-@@ -28,6 +28,8 @@

- # endif /* !DYNAMIC_CRC_TABLE */

- #endif /* MAKECRCH */

-+#include "deflate.h"

-+#include "x86.h"

- #include "zutil.h" /* for STDC and FAR definitions */

- #define local static

-@@ -423,3 +425,28 @@ uLong ZEXPORT crc32_combine64(crc1, crc2, len2)

- {

- return crc32_combine_(crc1, crc2, len2);

- }

-+ZLIB_INTERNAL void crc_reset(deflate_state *const s)

-+{

-+ if (x86_cpu_enable_simd) {

-+ crc_fold_init(s);

-+ return;

-+ }

-+ s->strm->adler = crc32(0L, Z_NULL, 0);

-+}

-+ZLIB_INTERNAL void crc_finalize(deflate_state *const s)

-+{

-+ if (x86_cpu_enable_simd)

-+ s->strm->adler = crc_fold_512to32(s);

-+}

-+ZLIB_INTERNAL void copy_with_crc(z_streamp strm, Bytef *dst, long size)

-+{

-+ if (x86_cpu_enable_simd) {

-+ crc_fold_copy(strm->state, dst, strm->next_in, size);

-+ return;

-+ }

-+ zmemcpy(dst, strm->next_in, size);

-+ strm->adler = crc32(strm->adler, dst, size);

-+}

-diff --git a/third_party/zlib/crc_folding.c b/third_party/zlib/crc_folding.c

-new file mode 100644

-index 0000000..48d7774

---- /dev/null

-+++ b/third_party/zlib/crc_folding.c

-@@ -0,0 +1,493 @@

-+/*

-+ * Compute the CRC32 using a parallelized folding approach with the PCLMULQDQ

-+ * instruction.

-+ *

-+ * A white paper describing this algorithm can be found at:

-+ * http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf

-+ *

-+ * Authors:

-+ * Wajdi Feghali <wajdi.k.feghali@intel.com>

-+ * Jim Guilford <james.guilford@intel.com>

-+ * Vinodh Gopal <vinodh.gopal@intel.com>

-+ * Erdinc Ozturk <erdinc.ozturk@intel.com>

-+ * Jim Kukunas <james.t.kukunas@linux.intel.com>

-+ *

-+ * For conditions of distribution and use, see copyright notice in zlib.h

-+ */

-+#include "deflate.h"

-+#include <inttypes.h>

-+#include <emmintrin.h>

-+#include <immintrin.h>

-+#include <wmmintrin.h>

-+#define CRC_LOAD(s) \

-+ do { \

-+ __m128i xmm_crc0 = _mm_loadu_si128((__m128i *)s->crc0 + 0);\

-+ __m128i xmm_crc1 = _mm_loadu_si128((__m128i *)s->crc0 + 1);\

-+ __m128i xmm_crc2 = _mm_loadu_si128((__m128i *)s->crc0 + 2);\

-+ __m128i xmm_crc3 = _mm_loadu_si128((__m128i *)s->crc0 + 3);\

-+ __m128i xmm_crc_part = _mm_loadu_si128((__m128i *)s->crc0 + 4);

-+#define CRC_SAVE(s) \

-+ _mm_storeu_si128((__m128i *)s->crc0 + 0, xmm_crc0);\

-+ _mm_storeu_si128((__m128i *)s->crc0 + 1, xmm_crc1);\

-+ _mm_storeu_si128((__m128i *)s->crc0 + 2, xmm_crc2);\

-+ _mm_storeu_si128((__m128i *)s->crc0 + 3, xmm_crc3);\

-+ _mm_storeu_si128((__m128i *)s->crc0 + 4, xmm_crc_part);\

-+ } while (0);

-+ZLIB_INTERNAL void crc_fold_init(deflate_state *const s)

-+{

-+ CRC_LOAD(s)

-+ xmm_crc0 = _mm_cvtsi32_si128(0x9db42487);

-+ xmm_crc1 = _mm_setzero_si128();

-+ xmm_crc2 = _mm_setzero_si128();

-+ xmm_crc3 = _mm_setzero_si128();

-+ CRC_SAVE(s)

-+ s->strm->adler = 0;

-+}

-+local void fold_1(deflate_state *const s,

-+ __m128i *xmm_crc0, __m128i *xmm_crc1,

-+ __m128i *xmm_crc2, __m128i *xmm_crc3)

-+{

-+ const __m128i xmm_fold4 = _mm_set_epi32(

-+ 0x00000001, 0x54442bd4,

-+ 0x00000001, 0xc6e41596);

-+ __m128i x_tmp3;

-+ __m128 ps_crc0, ps_crc3, ps_res;

-+ x_tmp3 = *xmm_crc3;

-+ *xmm_crc3 = *xmm_crc0;

-+ *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);

-+ *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x10);

-+ ps_crc0 = _mm_castsi128_ps(*xmm_crc0);

-+ ps_crc3 = _mm_castsi128_ps(*xmm_crc3);

-+ ps_res = _mm_xor_ps(ps_crc0, ps_crc3);

-+ *xmm_crc0 = *xmm_crc1;

-+ *xmm_crc1 = *xmm_crc2;

-+ *xmm_crc2 = x_tmp3;

-+ *xmm_crc3 = _mm_castps_si128(ps_res);

-+}

-+local void fold_2(deflate_state *const s,

-+ __m128i *xmm_crc0, __m128i *xmm_crc1,

-+ __m128i *xmm_crc2, __m128i *xmm_crc3)

-+{

-+ const __m128i xmm_fold4 = _mm_set_epi32(

-+ 0x00000001, 0x54442bd4,

-+ 0x00000001, 0xc6e41596);

-+ __m128i x_tmp3, x_tmp2;

-+ __m128 ps_crc0, ps_crc1, ps_crc2, ps_crc3, ps_res31, ps_res20;

-+ x_tmp3 = *xmm_crc3;

-+ x_tmp2 = *xmm_crc2;

-+ *xmm_crc3 = *xmm_crc1;

-+ *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x01);

-+ *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x10);

-+ ps_crc3 = _mm_castsi128_ps(*xmm_crc3);

-+ ps_crc1 = _mm_castsi128_ps(*xmm_crc1);

-+ ps_res31= _mm_xor_ps(ps_crc3, ps_crc1);

-+ *xmm_crc2 = *xmm_crc0;

-+ *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);

-+ *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x10);

-+ ps_crc0 = _mm_castsi128_ps(*xmm_crc0);

-+ ps_crc2 = _mm_castsi128_ps(*xmm_crc2);

-+ ps_res20= _mm_xor_ps(ps_crc0, ps_crc2);

-+ *xmm_crc0 = x_tmp2;

-+ *xmm_crc1 = x_tmp3;

-+ *xmm_crc2 = _mm_castps_si128(ps_res20);

-+ *xmm_crc3 = _mm_castps_si128(ps_res31);

-+}

-+local void fold_3(deflate_state *const s,

-+ __m128i *xmm_crc0, __m128i *xmm_crc1,

-+ __m128i *xmm_crc2, __m128i *xmm_crc3)

-+{

-+ const __m128i xmm_fold4 = _mm_set_epi32(

-+ 0x00000001, 0x54442bd4,

-+ 0x00000001, 0xc6e41596);

-+ __m128i x_tmp3;

-+ __m128 ps_crc0, ps_crc1, ps_crc2, ps_crc3, ps_res32, ps_res21, ps_res10;

-+ x_tmp3 = *xmm_crc3;

-+ *xmm_crc3 = *xmm_crc2;

-+ *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x01);

-+ *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x10);

-+ ps_crc2 = _mm_castsi128_ps(*xmm_crc2);

-+ ps_crc3 = _mm_castsi128_ps(*xmm_crc3);

-+ ps_res32 = _mm_xor_ps(ps_crc2, ps_crc3);

-+ *xmm_crc2 = *xmm_crc1;

-+ *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x01);

-+ *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x10);

-+ ps_crc1 = _mm_castsi128_ps(*xmm_crc1);

-+ ps_crc2 = _mm_castsi128_ps(*xmm_crc2);

-+ ps_res21= _mm_xor_ps(ps_crc1, ps_crc2);

-+ *xmm_crc1 = *xmm_crc0;

-+ *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);

-+ *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x10);

-+ ps_crc0 = _mm_castsi128_ps(*xmm_crc0);

-+ ps_crc1 = _mm_castsi128_ps(*xmm_crc1);

-+ ps_res10= _mm_xor_ps(ps_crc0, ps_crc1);

-+ *xmm_crc0 = x_tmp3;

-+ *xmm_crc1 = _mm_castps_si128(ps_res10);

-+ *xmm_crc2 = _mm_castps_si128(ps_res21);

-+ *xmm_crc3 = _mm_castps_si128(ps_res32);

-+}

-+local void fold_4(deflate_state *const s,

-+ __m128i *xmm_crc0, __m128i *xmm_crc1,

-+ __m128i *xmm_crc2, __m128i *xmm_crc3)

-+{

-+ const __m128i xmm_fold4 = _mm_set_epi32(

-+ 0x00000001, 0x54442bd4,

-+ 0x00000001, 0xc6e41596);

-+ __m128i x_tmp0, x_tmp1, x_tmp2, x_tmp3;

-+ __m128 ps_crc0, ps_crc1, ps_crc2, ps_crc3;

-+ __m128 ps_t0, ps_t1, ps_t2, ps_t3;

-+ __m128 ps_res0, ps_res1, ps_res2, ps_res3;

-+ x_tmp0 = *xmm_crc0;

-+ x_tmp1 = *xmm_crc1;

-+ x_tmp2 = *xmm_crc2;

-+ x_tmp3 = *xmm_crc3;

-+ *xmm_crc0 = _mm_clmulepi64_si128(*xmm_crc0, xmm_fold4, 0x01);

-+ x_tmp0 = _mm_clmulepi64_si128(x_tmp0, xmm_fold4, 0x10);

-+ ps_crc0 = _mm_castsi128_ps(*xmm_crc0);

-+ ps_t0 = _mm_castsi128_ps(x_tmp0);

-+ ps_res0 = _mm_xor_ps(ps_crc0, ps_t0);

-+ *xmm_crc1 = _mm_clmulepi64_si128(*xmm_crc1, xmm_fold4, 0x01);

-+ x_tmp1 = _mm_clmulepi64_si128(x_tmp1, xmm_fold4, 0x10);

-+ ps_crc1 = _mm_castsi128_ps(*xmm_crc1);

-+ ps_t1 = _mm_castsi128_ps(x_tmp1);

-+ ps_res1 = _mm_xor_ps(ps_crc1, ps_t1);

-+ *xmm_crc2 = _mm_clmulepi64_si128(*xmm_crc2, xmm_fold4, 0x01);

-+ x_tmp2 = _mm_clmulepi64_si128(x_tmp2, xmm_fold4, 0x10);

-+ ps_crc2 = _mm_castsi128_ps(*xmm_crc2);

-+ ps_t2 = _mm_castsi128_ps(x_tmp2);

-+ ps_res2 = _mm_xor_ps(ps_crc2, ps_t2);

-+ *xmm_crc3 = _mm_clmulepi64_si128(*xmm_crc3, xmm_fold4, 0x01);

-+ x_tmp3 = _mm_clmulepi64_si128(x_tmp3, xmm_fold4, 0x10);

-+ ps_crc3 = _mm_castsi128_ps(*xmm_crc3);

-+ ps_t3 = _mm_castsi128_ps(x_tmp3);

-+ ps_res3 = _mm_xor_ps(ps_crc3, ps_t3);

-+ *xmm_crc0 = _mm_castps_si128(ps_res0);

-+ *xmm_crc1 = _mm_castps_si128(ps_res1);

-+ *xmm_crc2 = _mm_castps_si128(ps_res2);

-+ *xmm_crc3 = _mm_castps_si128(ps_res3);

-+}

-+local const unsigned zalign(32) pshufb_shf_table[60] = {

-+ 0x84838281,0x88878685,0x8c8b8a89,0x008f8e8d, /* shl 15 (16 - 1)/shr1 */

-+ 0x85848382,0x89888786,0x8d8c8b8a,0x01008f8e, /* shl 14 (16 - 3)/shr2 */

-+ 0x86858483,0x8a898887,0x8e8d8c8b,0x0201008f, /* shl 13 (16 - 4)/shr3 */

-+ 0x87868584,0x8b8a8988,0x8f8e8d8c,0x03020100, /* shl 12 (16 - 4)/shr4 */

-+ 0x88878685,0x8c8b8a89,0x008f8e8d,0x04030201, /* shl 11 (16 - 5)/shr5 */

-+ 0x89888786,0x8d8c8b8a,0x01008f8e,0x05040302, /* shl 10 (16 - 6)/shr6 */

-+ 0x8a898887,0x8e8d8c8b,0x0201008f,0x06050403, /* shl 9 (16 - 7)/shr7 */

-+ 0x8b8a8988,0x8f8e8d8c,0x03020100,0x07060504, /* shl 8 (16 - 8)/shr8 */

-+ 0x8c8b8a89,0x008f8e8d,0x04030201,0x08070605, /* shl 7 (16 - 9)/shr9 */

-+ 0x8d8c8b8a,0x01008f8e,0x05040302,0x09080706, /* shl 6 (16 -10)/shr10*/

-+ 0x8e8d8c8b,0x0201008f,0x06050403,0x0a090807, /* shl 5 (16 -11)/shr11*/

-+ 0x8f8e8d8c,0x03020100,0x07060504,0x0b0a0908, /* shl 4 (16 -12)/shr12*/

-+ 0x008f8e8d,0x04030201,0x08070605,0x0c0b0a09, /* shl 3 (16 -13)/shr13*/

-+ 0x01008f8e,0x05040302,0x09080706,0x0d0c0b0a, /* shl 2 (16 -14)/shr14*/

-+ 0x0201008f,0x06050403,0x0a090807,0x0e0d0c0b /* shl 1 (16 -15)/shr15*/

-+};

-+local void partial_fold(deflate_state *const s, const size_t len,

-+ __m128i *xmm_crc0, __m128i *xmm_crc1,

-+ __m128i *xmm_crc2, __m128i *xmm_crc3,

-+ __m128i *xmm_crc_part)

-+{

-+ const __m128i xmm_fold4 = _mm_set_epi32(

-+ 0x00000001, 0x54442bd4,

-+ 0x00000001, 0xc6e41596);

-+ const __m128i xmm_mask3 = _mm_set1_epi32(0x80808080);

-+ __m128i xmm_shl, xmm_shr, xmm_tmp1, xmm_tmp2, xmm_tmp3;

-+ __m128i xmm_a0_0, xmm_a0_1;

-+ __m128 ps_crc3, psa0_0, psa0_1, ps_res;

-+ xmm_shl = _mm_load_si128((__m128i *)pshufb_shf_table + (len - 1));

-+ xmm_shr = xmm_shl;

-+ xmm_shr = _mm_xor_si128(xmm_shr, xmm_mask3);

-+ xmm_a0_0 = _mm_shuffle_epi8(*xmm_crc0, xmm_shl);

-+ *xmm_crc0 = _mm_shuffle_epi8(*xmm_crc0, xmm_shr);

-+ xmm_tmp1 = _mm_shuffle_epi8(*xmm_crc1, xmm_shl);

-+ *xmm_crc0 = _mm_or_si128(*xmm_crc0, xmm_tmp1);

-+ *xmm_crc1 = _mm_shuffle_epi8(*xmm_crc1, xmm_shr);

-+ xmm_tmp2 = _mm_shuffle_epi8(*xmm_crc2, xmm_shl);

-+ *xmm_crc1 = _mm_or_si128(*xmm_crc1, xmm_tmp2);

-+ *xmm_crc2 = _mm_shuffle_epi8(*xmm_crc2, xmm_shr);

-+ xmm_tmp3 = _mm_shuffle_epi8(*xmm_crc3, xmm_shl);

-+ *xmm_crc2 = _mm_or_si128(*xmm_crc2, xmm_tmp3);

-+ *xmm_crc3 = _mm_shuffle_epi8(*xmm_crc3, xmm_shr);

-+ *xmm_crc_part = _mm_shuffle_epi8(*xmm_crc_part, xmm_shl);

-+ *xmm_crc3 = _mm_or_si128(*xmm_crc3, *xmm_crc_part);

-+ xmm_a0_1 = _mm_clmulepi64_si128(xmm_a0_0, xmm_fold4, 0x10);

-+ xmm_a0_0 = _mm_clmulepi64_si128(xmm_a0_0, xmm_fold4, 0x01);

-+ ps_crc3 = _mm_castsi128_ps(*xmm_crc3);

-+ psa0_0 = _mm_castsi128_ps(xmm_a0_0);

-+ psa0_1 = _mm_castsi128_ps(xmm_a0_1);

-+ ps_res = _mm_xor_ps(ps_crc3, psa0_0);

-+ ps_res = _mm_xor_ps(ps_res, psa0_1);

-+ *xmm_crc3 = _mm_castps_si128(ps_res);

-+}

-+ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s,

-+ unsigned char *dst, const unsigned char *src, long len)

-+{

-+ unsigned long algn_diff;

-+ __m128i xmm_t0, xmm_t1, xmm_t2, xmm_t3;

-+ CRC_LOAD(s)

-+ if (len < 16) {

-+ if (len == 0)

-+ return;

-+ goto partial;

-+ }

-+ algn_diff = 0 - (uintptr_t)src & 0xF;

-+ if (algn_diff) {

-+ xmm_crc_part = _mm_loadu_si128((__m128i *)src);

-+ _mm_storeu_si128((__m128i *)dst, xmm_crc_part);

-+ dst += algn_diff;

-+ src += algn_diff;

-+ len -= algn_diff;

-+ partial_fold(s, algn_diff, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3,

-+ &xmm_crc_part);

-+ }

-+ while ((len -= 64) >= 0) {

-+ xmm_t0 = _mm_load_si128((__m128i *)src);

-+ xmm_t1 = _mm_load_si128((__m128i *)src + 1);

-+ xmm_t2 = _mm_load_si128((__m128i *)src + 2);

-+ xmm_t3 = _mm_load_si128((__m128i *)src + 3);

-+ fold_4(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);

-+ _mm_storeu_si128((__m128i *)dst, xmm_t0);

-+ _mm_storeu_si128((__m128i *)dst + 1, xmm_t1);

-+ _mm_storeu_si128((__m128i *)dst + 2, xmm_t2);

-+ _mm_storeu_si128((__m128i *)dst + 3, xmm_t3);

-+ xmm_crc0 = _mm_xor_si128(xmm_crc0, xmm_t0);

-+ xmm_crc1 = _mm_xor_si128(xmm_crc1, xmm_t1);

-+ xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_t2);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t3);

-+ src += 64;

-+ dst += 64;

-+ }

-+ /*

-+ * len = num bytes left - 64

-+ */

-+ if (len + 16 >= 0) {

-+ len += 16;

-+ xmm_t0 = _mm_load_si128((__m128i *)src);

-+ xmm_t1 = _mm_load_si128((__m128i *)src + 1);

-+ xmm_t2 = _mm_load_si128((__m128i *)src + 2);

-+ fold_3(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);

-+ _mm_storeu_si128((__m128i *)dst, xmm_t0);

-+ _mm_storeu_si128((__m128i *)dst + 1, xmm_t1);

-+ _mm_storeu_si128((__m128i *)dst + 2, xmm_t2);

-+ xmm_crc1 = _mm_xor_si128(xmm_crc1, xmm_t0);

-+ xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_t1);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t2);

-+ if (len == 0)

-+ goto done;

-+ dst += 48;

-+ src += 48;

-+ } else if (len + 32 >= 0) {

-+ len += 32;

-+ xmm_t0 = _mm_load_si128((__m128i *)src);

-+ xmm_t1 = _mm_load_si128((__m128i *)src + 1);

-+ fold_2(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);

-+ _mm_storeu_si128((__m128i *)dst, xmm_t0);

-+ _mm_storeu_si128((__m128i *)dst + 1, xmm_t1);

-+ xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_t0);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t1);

-+ if (len == 0)

-+ goto done;

-+ dst += 32;

-+ src += 32;

-+ } else if (len + 48 >= 0) {

-+ len += 48;

-+ xmm_t0 = _mm_load_si128((__m128i *)src);

-+ fold_1(s, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3);

-+ _mm_storeu_si128((__m128i *)dst, xmm_t0);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_t0);

-+ if (len == 0)

-+ goto done;

-+ dst += 16;

-+ src += 16;

-+ } else {

-+ len += 64;

-+ if (len == 0)

-+ goto done;

-+ }

-+partial:

-+#if defined(_MSC_VER)

-+ /* VS does not permit the use of _mm_set_epi64x in 32-bit builds */

-+ {

-+ int32_t parts[4] = {0, 0, 0, 0};

-+ memcpy(&parts, src, len);

-+ xmm_crc_part = _mm_set_epi32(parts[3], parts[2], parts[1], parts[0]);

-+ }

-+#else

-+ {

-+ int64_t parts[2] = {0, 0};

-+ memcpy(&parts, src, len);

-+ xmm_crc_part = _mm_set_epi64x(parts[1], parts[0]);

-+ }

-+#endif

-+ _mm_storeu_si128((__m128i *)dst, xmm_crc_part);

-+ partial_fold(s, len, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3,

-+ &xmm_crc_part);

-+done:

-+ CRC_SAVE(s)

-+}

-+local const unsigned zalign(16) crc_k[] = {

-+ 0xccaa009e, 0x00000000, /* rk1 */

-+ 0x751997d0, 0x00000001, /* rk2 */

-+ 0xccaa009e, 0x00000000, /* rk5 */

-+ 0x63cd6124, 0x00000001, /* rk6 */

-+ 0xf7011640, 0x00000001, /* rk7 */

-+ 0xdb710640, 0x00000001 /* rk8 */

-+};

-+local const unsigned zalign(16) crc_mask[4] = {

-+ 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000

-+};

-+local const unsigned zalign(16) crc_mask2[4] = {

-+ 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF

-+};

-+unsigned ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s)

-+{

-+ const __m128i xmm_mask = _mm_load_si128((__m128i *)crc_mask);

-+ const __m128i xmm_mask2 = _mm_load_si128((__m128i *)crc_mask2);

-+ unsigned crc;

-+ __m128i x_tmp0, x_tmp1, x_tmp2, crc_fold;

-+ CRC_LOAD(s)

-+ /*

-+ * k1

-+ */

-+ crc_fold = _mm_load_si128((__m128i *)crc_k);

-+ x_tmp0 = _mm_clmulepi64_si128(xmm_crc0, crc_fold, 0x10);

-+ xmm_crc0 = _mm_clmulepi64_si128(xmm_crc0, crc_fold, 0x01);

-+ xmm_crc1 = _mm_xor_si128(xmm_crc1, x_tmp0);

-+ xmm_crc1 = _mm_xor_si128(xmm_crc1, xmm_crc0);

-+ x_tmp1 = _mm_clmulepi64_si128(xmm_crc1, crc_fold, 0x10);

-+ xmm_crc1 = _mm_clmulepi64_si128(xmm_crc1, crc_fold, 0x01);

-+ xmm_crc2 = _mm_xor_si128(xmm_crc2, x_tmp1);

-+ xmm_crc2 = _mm_xor_si128(xmm_crc2, xmm_crc1);

-+ x_tmp2 = _mm_clmulepi64_si128(xmm_crc2, crc_fold, 0x10);

-+ xmm_crc2 = _mm_clmulepi64_si128(xmm_crc2, crc_fold, 0x01);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, x_tmp2);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);

-+ /*

-+ * k5

-+ */

-+ crc_fold = _mm_load_si128((__m128i *)crc_k + 1);

-+ xmm_crc0 = xmm_crc3;

-+ xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0);

-+ xmm_crc0 = _mm_srli_si128(xmm_crc0, 8);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc0);

-+ xmm_crc0 = xmm_crc3;

-+ xmm_crc3 = _mm_slli_si128(xmm_crc3, 4);

-+ xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0x10);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc0);

-+ xmm_crc3 = _mm_and_si128(xmm_crc3, xmm_mask2);

-+ /*

-+ * k7

-+ */

-+ xmm_crc1 = xmm_crc3;

-+ xmm_crc2 = xmm_crc3;

-+ crc_fold = _mm_load_si128((__m128i *)crc_k + 2);

-+ xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);

-+ xmm_crc3 = _mm_and_si128(xmm_crc3, xmm_mask);

-+ xmm_crc2 = xmm_crc3;

-+ xmm_crc3 = _mm_clmulepi64_si128(xmm_crc3, crc_fold, 0x10);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc2);

-+ xmm_crc3 = _mm_xor_si128(xmm_crc3, xmm_crc1);

-+ crc = _mm_extract_epi32(xmm_crc3, 2);

-+ return ~crc;

-+ CRC_SAVE(s)

-+}

-diff --git a/third_party/zlib/deflate.c b/third_party/zlib/deflate.c

-index 7c95b30..59645eb 100644

---- a/third_party/zlib/deflate.c

-+++ b/third_party/zlib/deflate.c

-@@ -48,8 +48,9 @@

- */

- /* @(#) $Id$ */

-+#include <assert.h>

- #include "deflate.h"

-+#include "x86.h"

- const char deflate_copyright[] =

-@@ -85,7 +86,7 @@ local block_state deflate_huff OF((deflate_state *s, int flush));

- local void lm_init OF((deflate_state *s));

- local void putShortMSB OF((deflate_state *s, uInt b));

- local void flush_pending OF((z_streamp strm));

--local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));

- #ifdef ASMV

- void match_init OF((void)); /* asm code initialization */

- uInt longest_match OF((deflate_state *s, IPos cur_match, int clas));

-@@ -98,6 +99,23 @@ local void check_match OF((deflate_state *s, IPos start, IPos match,

- int length));

- #endif

-+/* For fill_window_sse.c to use */

-+ZLIB_INTERNAL int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));

-+/* From crc32.c */

-+extern void ZLIB_INTERNAL crc_reset(deflate_state *const s);

-+extern void ZLIB_INTERNAL crc_finalize(deflate_state *const s);

-+extern void ZLIB_INTERNAL copy_with_crc(z_streamp strm, Bytef *dst, long size);

-+#ifdef _MSC_VER

-+#define INLINE __inline

-+#else

-+#define INLINE inline

-+#endif

-+/* Inline optimisation */

-+local INLINE Pos insert_string_sse(deflate_state *const s, const Pos str);

- /* ===========================================================================

- * Local data

- */

-@@ -167,7 +185,6 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */

- */

- #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)

- /* ===========================================================================

- * Insert string str in the dictionary and set match_head to the previous head

- * of the hash chain (the most recent string with same hash key). Return

-@@ -178,17 +195,28 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */

- * input characters and the first MIN_MATCH bytes of str are valid

- * (except for the last MIN_MATCH-1 bytes of the input file).

- */

-+local INLINE Pos insert_string_c(deflate_state *const s, const Pos str)

-+{

-+ Pos ret;

-+ UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]);

- #ifdef FASTEST

--#define INSERT_STRING(s, str, match_head) \

-- (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \

-- match_head = s->head[s->ins_h], \

-- s->head[s->ins_h] = (Pos)(str))

-+ ret = s->head[s->ins_h];

- #else

--#define INSERT_STRING(s, str, match_head) \

-- (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \

-- match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \

-- s->head[s->ins_h] = (Pos)(str))

-+ ret = s->prev[str & s->w_mask] = s->head[s->ins_h];

- #endif

-+ s->head[s->ins_h] = str;

-+ return ret;

-+}

-+local INLINE Pos insert_string(deflate_state *const s, const Pos str)

-+{

-+ if (x86_cpu_enable_simd)

-+ return insert_string_sse(s, str);

-+ return insert_string_c(s, str);

-+}

- /* ===========================================================================

- * Initialize the hash table (avoiding 64K overflow for 16 bit systems).

-@@ -222,6 +250,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,

- const char *version;

- int stream_size;

- {

-+ unsigned window_padding = 8;

- deflate_state *s;

- int wrap = 1;

- static const char my_version[] = ZLIB_VERSION;

-@@ -231,6 +260,8 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,

- * output size for (length,distance) codes is <= 24 bits.

- */

-+ x86_check_features();

- if (version == Z_NULL || version[0] != my_version[0] ||

- stream_size != sizeof(z_stream)) {

- return Z_VERSION_ERROR;

-@@ -286,12 +317,17 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,

- s->w_size = 1 << s->w_bits;

- s->w_mask = s->w_size - 1;

-- s->hash_bits = memLevel + 7;

-+ if (x86_cpu_enable_simd) {

-+ s->hash_bits = 15;

-+ } else {

-+ s->hash_bits = memLevel + 7;

-+ }

- s->hash_size = 1 << s->hash_bits;

- s->hash_mask = s->hash_size - 1;

- s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);

-- s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));

-+ s->window = (Bytef *) ZALLOC(strm, s->w_size + window_padding, 2*sizeof(Byte));

- s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));

- s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));

- s->class_bitmap = NULL;

-@@ -369,11 +405,7 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)

- str = s->strstart;

- n = s->lookahead - (MIN_MATCH-1);

- do {

-- UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);

--#ifndef FASTEST

-- s->prev[str & s->w_mask] = s->head[s->ins_h];

--#endif

-- s->head[s->ins_h] = (Pos)str;

-+ insert_string(s, str);

- str++;

- } while (--n);

- s->strstart = str;

-@@ -696,7 +728,7 @@ int ZEXPORT deflate (strm, flush)

- if (s->status == INIT_STATE) {

- #ifdef GZIP

- if (s->wrap == 2) {

-- strm->adler = crc32(0L, Z_NULL, 0);

-+ crc_reset(s);

- put_byte(s, 31);

- put_byte(s, 139);

- put_byte(s, 8);

-@@ -975,6 +1007,7 @@ int ZEXPORT deflate (strm, flush)

- /* Write the trailer */

- #ifdef GZIP

- if (s->wrap == 2) {

-+ crc_finalize(s);

- put_byte(s, (Byte)(strm->adler & 0xff));

- put_byte(s, (Byte)((strm->adler >> 8) & 0xff));

- put_byte(s, (Byte)((strm->adler >> 16) & 0xff));

-@@ -1097,7 +1130,7 @@ int ZEXPORT deflateCopy (dest, source)

- * allocating a large strm->next_in buffer and copying from it.

- * (See also flush_pending()).

- */

--local int read_buf(strm, buf, size)

-+ZLIB_INTERNAL int read_buf(strm, buf, size)

- z_streamp strm;

- Bytef *buf;

- unsigned size;

-@@ -1109,15 +1142,16 @@ local int read_buf(strm, buf, size)

- strm->avail_in -= len;

-- zmemcpy(buf, strm->next_in, len);

-- if (strm->state->wrap == 1) {

-- strm->adler = adler32(strm->adler, buf, len);

-- }

- #ifdef GZIP

-- else if (strm->state->wrap == 2) {

-- strm->adler = crc32(strm->adler, buf, len);

-- }

-+ if (strm->state->wrap == 2)

-+ copy_with_crc(strm, buf, len);

-+ else

- #endif

-+ {

-+ zmemcpy(buf, strm->next_in, len);

-+ if (strm->state->wrap == 1)

-+ strm->adler = adler32(strm->adler, buf, len);

-+ }

- strm->next_in += len;

- strm->total_in += len;

-@@ -1530,7 +1564,19 @@ local void check_match(s, start, match, length)

- * performed for at least two bytes (required for the zip translate_eol

- * option -- not supported here).

- */

--local void fill_window(s)

-+local void fill_window_c(deflate_state *s);

-+local void fill_window(deflate_state *s)

-+{

-+ if (x86_cpu_enable_simd) {

-+ fill_window_sse(s);

-+ return;

-+ }

-+ fill_window_c(s);

-+}

-+local void fill_window_c(s)

- deflate_state *s;

- {

- register unsigned n, m;

-@@ -1818,7 +1864,7 @@ local block_state deflate_fast(s, flush, clas)

- */

- hash_head = NIL;

- if (s->lookahead >= MIN_MATCH) {

-- INSERT_STRING(s, s->strstart, hash_head);

-+ hash_head = insert_string(s, s->strstart);

- }

- /* Find the longest match, discarding those <= prev_length.

-@@ -1849,7 +1895,7 @@ local block_state deflate_fast(s, flush, clas)

- s->match_length--; /* string at strstart already in table */

- do {

- s->strstart++;

-- INSERT_STRING(s, s->strstart, hash_head);

-+ hash_head = insert_string(s, s->strstart);

- /* strstart never exceeds WSIZE-MAX_MATCH, so there are

- * always MIN_MATCH bytes ahead.

- */

-@@ -1934,7 +1980,7 @@ local block_state deflate_slow(s, flush, clas)

- */

- hash_head = NIL;

- if (s->lookahead >= MIN_MATCH) {

-- INSERT_STRING(s, s->strstart, hash_head);

-+ hash_head = insert_string(s, s->strstart);

- }

- /* Find the longest match, discarding those <= prev_length.

-@@ -2003,7 +2049,7 @@ local block_state deflate_slow(s, flush, clas)

- s->prev_length -= 2;

- do {

- if (++s->strstart <= max_insert) {

-- INSERT_STRING(s, s->strstart, hash_head);

-+ hash_head = insert_string(s, s->strstart);

- }

- } while (--s->prev_length != 0);

- s->match_available = 0;

-@@ -2163,3 +2209,37 @@ local block_state deflate_huff(s, flush)

- FLUSH_BLOCK(s, 0);

- return block_done;

- }

-+/* Safe to inline this as GCC/clang will use inline asm and Visual Studio will

-+ * use intrinsic without extra params

-+ */

-+local INLINE Pos insert_string_sse(deflate_state *const s, const Pos str)

-+{

-+ Pos ret;

-+ unsigned *ip, val, h = 0;

-+ ip = (unsigned *)&s->window[str];

-+ val = *ip;

-+ if (s->level >= 6)

-+ val &= 0xFFFFFF;

-+/* Windows clang should use inline asm */

-+#if defined(_MSC_VER) && !defined(__clang__)

-+ h = _mm_crc32_u32(h, val);

-+#elif defined(__i386__) || defined(__amd64__)

-+ __asm__ __volatile__ (

-+ "crc32 %1,%0\n\t"

-+ : "+r" (h)

-+ : "r" (val)

-+ );

-+#else

-+ /* This should never happen */

-+ assert(0);

-+#endif

-+ ret = s->head[h & s->hash_mask];

-+ s->head[h & s->hash_mask] = str;

-+ s->prev[str & s->w_mask] = ret;

-+ return ret;

-+}

-diff --git a/third_party/zlib/deflate.h b/third_party/zlib/deflate.h

-index c795034..c61e4ab 100644

---- a/third_party/zlib/deflate.h

-+++ b/third_party/zlib/deflate.h

-@@ -109,7 +109,7 @@ typedef struct internal_state {

- uInt gzindex; /* where in extra, name, or comment */

- Byte method; /* can only be DEFLATED */

- int last_flush; /* value of flush param for previous deflate call */

-+ unsigned zalign(16) crc0[4 * 5];

- /* used by deflate.c: */

- uInt w_size; /* LZ77 window size (32K by default) */

-@@ -348,4 +348,14 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,

- flush = _tr_tally(s, distance, length)

- #endif

-+/* Functions that are SIMD optimised on x86 */

-+void ZLIB_INTERNAL crc_fold_init(deflate_state* const s);

-+void ZLIB_INTERNAL crc_fold_copy(deflate_state* const s,

-+ unsigned char* dst,

-+ const unsigned char* src,

-+ long len);

-+unsigned ZLIB_INTERNAL crc_fold_512to32(deflate_state* const s);

-+void ZLIB_INTERNAL fill_window_sse(deflate_state* s);

- #endif /* DEFLATE_H */

-diff --git a/third_party/zlib/fill_window_sse.c b/third_party/zlib/fill_window_sse.c

-new file mode 100644

-index 0000000..949ccce

---- /dev/null

-+++ b/third_party/zlib/fill_window_sse.c

-@@ -0,0 +1,175 @@

-+/*

-+ * Fill Window with SSE2-optimized hash shifting

-+ *

-+ * Authors:

-+ * Arjan van de Ven <arjan@linux.intel.com>

-+ * Jim Kukunas <james.t.kukunas@linux.intel.com>

-+ *

-+ * For conditions of distribution and use, see copyright notice in zlib.h

-+ */

-+#include <immintrin.h>

-+#include "deflate.h"

-+#define UPDATE_HASH(s,h,i) \

-+ {\

-+ if (s->level < 6) { \

-+ h = (3483 * (s->window[i]) +\

-+ 23081* (s->window[i+1]) +\

-+ 6954 * (s->window[i+2]) +\

-+ 20947* (s->window[i+3])) & s->hash_mask;\

-+ } else {\

-+ h = (25881* (s->window[i]) +\

-+ 24674* (s->window[i+1]) +\

-+ 25811* (s->window[i+2])) & s->hash_mask;\

-+ }\

-+extern int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));

-+void fill_window_sse(deflate_state *s)

-+{

-+ const __m128i xmm_wsize = _mm_set1_epi16(s->w_size);

-+ register unsigned n;

-+ register Posf *p;

-+ unsigned more; /* Amount of free space at the end of the window. */

-+ uInt wsize = s->w_size;

-+ Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");

-+ do {

-+ more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);

-+ /* Deal with !@#$% 64K limit: */

-+ if (sizeof(int) <= 2) {

-+ if (more == 0 && s->strstart == 0 && s->lookahead == 0) {

-+ more = wsize;

-+ } else if (more == (unsigned)(-1)) {

-+ /* Very unlikely, but possible on 16 bit machine if

-+ * strstart == 0 && lookahead == 1 (input done a byte at time)

-+ */

-+ more--;

-+ }

-+ /* If the window is almost full and there is insufficient lookahead,

-+ * move the upper half to the lower one to make room in the upper half.

-+ */

-+ if (s->strstart >= wsize+MAX_DIST(s)) {

-+ zmemcpy(s->window, s->window+wsize, (unsigned)wsize);

-+ s->match_start -= wsize;

-+ s->strstart -= wsize; /* we now have strstart >= MAX_DIST */

-+ s->block_start -= (long) wsize;

-+ /* Slide the hash table (could be avoided with 32 bit values

-+ at the expense of memory usage). We slide even when level == 0

-+ to keep the hash table consistent if we switch back to level > 0

-+ later. (Using level 0 permanently is not an optimal usage of

-+ zlib, so we don't care about this pathological case.)

-+ */

-+ n = s->hash_size;

-+ p = &s->head[n];

-+ p -= 8;

-+ do {

-+ __m128i value, result;

-+ value = _mm_loadu_si128((__m128i *)p);

-+ result = _mm_subs_epu16(value, xmm_wsize);

-+ _mm_storeu_si128((__m128i *)p, result);

-+ p -= 8;

-+ n -= 8;

-+ } while (n > 0);

-+ n = wsize;

-+#ifndef FASTEST

-+ p = &s->prev[n];

-+ p -= 8;

-+ do {

-+ __m128i value, result;

-+ value = _mm_loadu_si128((__m128i *)p);

-+ result = _mm_subs_epu16(value, xmm_wsize);

-+ _mm_storeu_si128((__m128i *)p, result);

-+ p -= 8;

-+ n -= 8;

-+ } while (n > 0);

-+#endif

-+ more += wsize;

-+ }

-+ if (s->strm->avail_in == 0) break;

-+ /* If there was no sliding:

-+ * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&

-+ * more == window_size - lookahead - strstart

-+ * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)

-+ * => more >= window_size - 2*WSIZE + 2

-+ * In the BIG_MEM or MMAP case (not yet supported),

-+ * window_size == input_size + MIN_LOOKAHEAD &&

-+ * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.

-+ * Otherwise, window_size == 2*WSIZE so more >= 2.

-+ * If there was sliding, more >= WSIZE. So in all cases, more >= 2.

-+ */

-+ Assert(more >= 2, "more < 2");

-+ n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);

-+ s->lookahead += n;

-+ /* Initialize the hash value now that we have some input: */

-+ if (s->lookahead >= MIN_MATCH) {

-+ uInt str = s->strstart;

-+ s->ins_h = s->window[str];

-+ if (str >= 1)

-+ UPDATE_HASH(s, s->ins_h, str + 1 - (MIN_MATCH-1));

-+#if MIN_MATCH != 3

-+ Call UPDATE_HASH() MIN_MATCH-3 more times

-+#endif

-+ }

-+ /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,

-+ * but this is not important since only literal bytes will be emitted.

-+ */

-+ } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);

-+ /* If the WIN_INIT bytes after the end of the current data have never been

-+ * written, then zero those bytes in order to avoid memory check reports of

-+ * the use of uninitialized (or uninitialised as Julian writes) bytes by

-+ * the longest match routines. Update the high water mark for the next

-+ * time through here. WIN_INIT is set to MAX_MATCH since the longest match

-+ * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.

-+ */

-+ if (s->high_water < s->window_size) {

-+ ulg curr = s->strstart + (ulg)(s->lookahead);

-+ ulg init;

-+ if (s->high_water < curr) {

-+ /* Previous high water mark below current data -- zero WIN_INIT

-+ * bytes or up to end of window, whichever is less.

-+ */

-+ init = s->window_size - curr;

-+ if (init > WIN_INIT)

-+ init = WIN_INIT;

-+ zmemzero(s->window + curr, (unsigned)init);

-+ s->high_water = curr + init;

-+ }

-+ else if (s->high_water < (ulg)curr + WIN_INIT) {

-+ /* High water mark at or above current data, but below current data

-+ * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up

-+ * to end of window, whichever is less.

-+ */

-+ init = (ulg)curr + WIN_INIT - s->high_water;

-+ if (init > s->window_size - s->high_water)

-+ init = s->window_size - s->high_water;

-+ zmemzero(s->window + s->high_water, (unsigned)init);

-+ s->high_water += init;

-+ }

-+ Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,

-+ "not enough room for search");

-+}

-diff --git a/third_party/zlib/simd_stub.c b/third_party/zlib/simd_stub.c

-new file mode 100644

-index 0000000..796f1f6

---- /dev/null

-+++ b/third_party/zlib/simd_stub.c

-@@ -0,0 +1,35 @@

-+/* simd_stub.c -- stub implementations

-+* For conditions of distribution and use, see copyright notice in zlib.h

-+*/

-+#include <assert.h>

-+#include "deflate.h"

-+#include "x86.h"

-+int x86_cpu_enable_simd = 0;

-+void ZLIB_INTERNAL crc_fold_init(deflate_state *const s) {

-+ assert(0);

-+}

-+void ZLIB_INTERNAL crc_fold_copy(deflate_state *const s,

-+ unsigned char *dst,

-+ const unsigned char *src,

-+ long len) {

-+ assert(0);

-+}

-+unsigned ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s) {

-+ assert(0);

-+ return 0;

-+}

-+void ZLIB_INTERNAL fill_window_sse(deflate_state *s)

-+{

-+ assert(0);

-+}

-+void x86_check_features(void)

-+{

-+}

-diff --git a/third_party/zlib/x86.c b/third_party/zlib/x86.c

-new file mode 100644

-index 0000000..e6532fd

---- /dev/null

-+++ b/third_party/zlib/x86.c

-@@ -0,0 +1,91 @@

-+/*

-+ * x86 feature check

-+ *

-+ * Author:

-+ * Jim Kukunas

-+ *

-+ * For conditions of distribution and use, see copyright notice in zlib.h

-+ */

-+#include "x86.h"

-+int x86_cpu_enable_simd = 0;

-+#ifndef _MSC_VER

-+#include <pthread.h>

-+pthread_once_t cpu_check_inited_once = PTHREAD_ONCE_INIT;

-+static void _x86_check_features(void);

-+void x86_check_features(void)

-+{

-+ pthread_once(&cpu_check_inited_once, _x86_check_features);

-+}

-+static void _x86_check_features(void)

-+{

-+ int x86_cpu_has_sse2;

-+ int x86_cpu_has_sse42;

-+ int x86_cpu_has_pclmulqdq;

-+ unsigned eax, ebx, ecx, edx;

-+ eax = 1;

-+#ifdef __i386__

-+ __asm__ __volatile__ (

-+ "xchg %%ebx, %1\n\t"

-+ "cpuid\n\t"

-+ "xchg %1, %%ebx\n\t"

-+ : "+a" (eax), "=S" (ebx), "=c" (ecx), "=d" (edx)

-+ );

-+#else

-+ __asm__ __volatile__ (

-+ "cpuid\n\t"

-+ : "+a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)

-+ );

-+#endif /* (__i386__) */

-+ x86_cpu_has_sse2 = edx & 0x4000000;

-+ x86_cpu_has_sse42 = ecx & 0x100000;

-+ x86_cpu_has_pclmulqdq = ecx & 0x2;

-+ x86_cpu_enable_simd = x86_cpu_has_sse2 &&

-+ x86_cpu_has_sse42 &&

-+ x86_cpu_has_pclmulqdq;

-+}

-+#else

-+#include <intrin.h>

-+#include <windows.h>

-+static BOOL CALLBACK _x86_check_features(PINIT_ONCE once,

-+ PVOID param,

-+ PVOID *context);

-+static INIT_ONCE cpu_check_inited_once = INIT_ONCE_STATIC_INIT;

-+void x86_check_features(void)

-+{

-+ InitOnceExecuteOnce(&cpu_check_inited_once, _x86_check_features,

-+ NULL, NULL);

-+}

-+static BOOL CALLBACK _x86_check_features(PINIT_ONCE once,

-+ PVOID param,

-+ PVOID *context)

-+{

-+ int x86_cpu_has_sse2;

-+ int x86_cpu_has_sse42;

-+ int x86_cpu_has_pclmulqdq;

-+ int regs[4];

-+ __cpuid(regs, 1);

-+ x86_cpu_has_sse2 = regs[3] & 0x4000000;

-+ x86_cpu_has_sse42= regs[2] & 0x100000;

-+ x86_cpu_has_pclmulqdq = regs[2] & 0x2;

-+ x86_cpu_enable_simd = x86_cpu_has_sse2 &&

-+ x86_cpu_has_sse42 &&

-+ x86_cpu_has_pclmulqdq;

-+ return TRUE;

-+}

-+#endif /* _MSC_VER */

-diff --git a/third_party/zlib/x86.h b/third_party/zlib/x86.h

-new file mode 100644

-index 0000000..ac3d180

---- /dev/null

-+++ b/third_party/zlib/x86.h

-@@ -0,0 +1,13 @@

-+/* x86.h -- check for x86 CPU features

-+* For conditions of distribution and use, see copyright notice in zlib.h

-+*/

-+#ifndef X86_H

-+#define X86_H

-+extern int x86_cpu_enable_simd;

-+void x86_check_features(void);

-+#endif /* X86_H */

---

-2.7.4

« no previous file with comments | « third_party/zlib/mozzconf.h ('k') | third_party/zlib/trees.c » ('j') | no next file with comments »