Revert of Update Zlib to version 1.2.8 (patchset #10 id:220001 of https://codereview.chromium.org/1955383002/ )
Reason for revert:
Broke the Windows Debug GPU FYI builder:
https://build.chromium.org/p/chromium.gpu.fyi/builders/GPU%20Win%20Builder%20%28dbg%29/builds/41421
fx_zlib.gzlib.obj : error LNK2005: _gzopen_w already defined in zlib.gzlib.obj
initial\chrome.dll : fatal error LNK1169: one or more multiply defined symbols found
Possibly because they use shared components with a GYP build.
Original issue's description:
> Update Zlib to version 1.2.8
>
> merge the latest open source zlib into chromium external projects
>
> Version 1.2.8 fixes a very rare bug in decompression. All users are encouraged to upgrade immediately. Version 1.2.8 also has these improvements:
> - Add new inflateGetDictionary() function
> - Fix bug where gzopen() immediately followed by gzclose() would write an empty file instead of an empty gzip stream.
> - Fix bug in gzclose() when gzwrite() runs out of memory
> Version 1.2.7 has many portability improvements over 1.2.6, and has these enhancements:
> - Fix bug in gzclose_w() when gzwrite() fails to allocate memory
> - Add "x" (O_EXCL) and "e" (O_CLOEXEC) modes support to gzopen()
> - Add gzopen_w() in Windows for wide character path names
> - Fix type mismatch between get_crc_table() and crc_table
> Version 1.2.6 has many changes over 1.2.5, including these improvements:
> - gzread() can now read a file that is being written concurrently
> - gzgetc() is now a macro for increased speed
> - Added a 'T' option to gzopen() for transparent writing (no compression)
> - Added deflatePending() to return the amount of pending output
> - Allow deflateSetDictionary() and inflateSetDictionary() at any time in raw mode
> - deflatePrime() can now insert bits in the middle of the stream
> - ./configure now creates a configure.log file with all of the results
> - Added a ./configure --solo option to compile zlib with no dependency on any libraries
> - Fixed a problem with large file support macros
> - Fixed a bug in contrib/puff
> - Many portability improvements
>
> BUG=610615
> R=agl@chromium.org
> R=gavinp@chromium.org
>
> Committed: https://crrev.com/a50849ae9ba1b2fad47905db521463b3bf085883
> Cr-Commit-Position: refs/heads/master@{#400647}
TBR=agl@chromium.org,gavinp@chromium.org,khasim.mohammed@linaro.org,jiadong.zhu@linaro.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=610615
Review-Url: https://codereview.chromium.org/2079313002
Cr-Original-Commit-Position: refs/heads/master@{#400670}
Cr-Mirrored-From: https://chromium.googlesource.com/chromium/src
Cr-Mirrored-Commit: 43770253ccc0425c4edde966e56b3e68955cc4d3
diff --git a/deflate.c b/deflate.c
index 59645eb..55ec215 100644
--- a/deflate.c
+++ b/deflate.c
@@ -1,5 +1,5 @@
/* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
+ * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
@@ -37,7 +37,7 @@
* REFERENCES
*
* Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
- * Available in http://tools.ietf.org/html/rfc1951
+ * Available in http://www.ietf.org/rfc/rfc1951.txt
*
* A description of the Rabin and Karp algorithm is given in the book
* "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
@@ -48,12 +48,14 @@
*/
/* @(#) $Id$ */
+
#include <assert.h>
+
#include "deflate.h"
#include "x86.h"
const char deflate_copyright[] =
- " deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ";
+ " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler ";
/*
If you use the zlib library in a product, an acknowledgment is welcome
in the documentation of your product. If for some reason you cannot
@@ -174,9 +176,6 @@
struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
#endif
-/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
-#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0))
-
/* ===========================================================================
* Update a hash value with the given input byte
* IN assertion: all calls to to UPDATE_HASH are made with consecutive
@@ -270,19 +269,10 @@
strm->msg = Z_NULL;
if (strm->zalloc == (alloc_func)0) {
-#ifdef Z_SOLO
- return Z_STREAM_ERROR;
-#else
strm->zalloc = zcalloc;
strm->opaque = (voidpf)0;
-#endif
}
- if (strm->zfree == (free_func)0)
-#ifdef Z_SOLO
- return Z_STREAM_ERROR;
-#else
- strm->zfree = zcfree;
-#endif
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
#ifdef FASTEST
if (level != 0) level = 1;
@@ -345,7 +335,7 @@
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
s->pending_buf == Z_NULL) {
s->status = FINISH_STATE;
- strm->msg = ERR_MSG(Z_MEM_ERROR);
+ strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
deflateEnd (strm);
return Z_MEM_ERROR;
}
@@ -366,66 +356,43 @@
uInt dictLength;
{
deflate_state *s;
- uInt str, n;
- int wrap;
- unsigned avail;
- z_const unsigned char *next;
+ uInt length = dictLength;
+ uInt n;
+ IPos hash_head = 0;
- if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
+ if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
+ strm->state->wrap == 2 ||
+ (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
return Z_STREAM_ERROR;
+
s = strm->state;
- wrap = s->wrap;
- if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
- return Z_STREAM_ERROR;
-
- /* when using zlib wrappers, compute Adler-32 for provided dictionary */
- if (wrap == 1)
+ if (s->wrap)
strm->adler = adler32(strm->adler, dictionary, dictLength);
- s->wrap = 0; /* avoid computing Adler-32 in read_buf */
- /* if dictionary would fill window, just replace the history */
- if (dictLength >= s->w_size) {
- if (wrap == 0) { /* already empty otherwise */
- CLEAR_HASH(s);
- s->strstart = 0;
- s->block_start = 0L;
- s->insert = 0;
- }
- dictionary += dictLength - s->w_size; /* use the tail */
- dictLength = s->w_size;
+ if (length < MIN_MATCH) return Z_OK;
+ if (length > s->w_size) {
+ length = s->w_size;
+ dictionary += dictLength - length; /* use the tail of the dictionary */
}
+ zmemcpy(s->window, dictionary, length);
+ s->strstart = length;
+ s->block_start = (long)length;
- /* insert dictionary into window and hash */
- avail = strm->avail_in;
- next = strm->next_in;
- strm->avail_in = dictLength;
- strm->next_in = (z_const Bytef *)dictionary;
- fill_window(s);
- while (s->lookahead >= MIN_MATCH) {
- str = s->strstart;
- n = s->lookahead - (MIN_MATCH-1);
- do {
- insert_string(s, str);
- str++;
- } while (--n);
- s->strstart = str;
- s->lookahead = MIN_MATCH-1;
- fill_window(s);
+ /* Insert all strings in the hash table (except for the last two bytes).
+ * s->lookahead stays null, so s->ins_h will be recomputed at the next
+ * call of fill_window.
+ */
+ s->ins_h = s->window[0];
+ UPDATE_HASH(s, s->ins_h, s->window[1]);
+ for (n = 0; n <= length - MIN_MATCH; n++) {
+ insert_string(s, n);
}
- s->strstart += s->lookahead;
- s->block_start = (long)s->strstart;
- s->insert = s->lookahead;
- s->lookahead = 0;
- s->match_length = s->prev_length = MIN_MATCH-1;
- s->match_available = 0;
- strm->next_in = next;
- strm->avail_in = avail;
- s->wrap = wrap;
+ if (hash_head) hash_head = 0; /* to make compiler happy */
return Z_OK;
}
/* ========================================================================= */
-int ZEXPORT deflateResetKeep (strm)
+int ZEXPORT deflateReset (strm)
z_streamp strm;
{
deflate_state *s;
@@ -457,23 +424,12 @@
s->last_flush = Z_NO_FLUSH;
_tr_init(s);
+ lm_init(s);
return Z_OK;
}
/* ========================================================================= */
-int ZEXPORT deflateReset (strm)
- z_streamp strm;
-{
- int ret;
-
- ret = deflateResetKeep(strm);
- if (ret == Z_OK)
- lm_init(strm->state);
- return ret;
-}
-
-/* ========================================================================= */
int ZEXPORT deflateSetHeader (strm, head)
z_streamp strm;
gz_headerp head;
@@ -485,42 +441,14 @@
}
/* ========================================================================= */
-int ZEXPORT deflatePending (strm, pending, bits)
- unsigned *pending;
- int *bits;
- z_streamp strm;
-{
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
- if (pending != Z_NULL)
- *pending = strm->state->pending;
- if (bits != Z_NULL)
- *bits = strm->state->bi_valid;
- return Z_OK;
-}
-
-/* ========================================================================= */
int ZEXPORT deflatePrime (strm, bits, value)
z_streamp strm;
int bits;
int value;
{
- deflate_state *s;
- int put;
-
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
- s = strm->state;
- if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
- return Z_BUF_ERROR;
- do {
- put = Buf_size - s->bi_valid;
- if (put > bits)
- put = bits;
- s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
- s->bi_valid += put;
- _tr_flush_bits(s);
- value >>= put;
- bits -= put;
- } while (bits);
+ strm->state->bi_valid = bits;
+ strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
return Z_OK;
}
@@ -551,8 +479,6 @@
strm->total_in != 0) {
/* Flush the last buffer: */
err = deflate(strm, Z_BLOCK);
- if (err == Z_BUF_ERROR && s->pending == 0)
- err = Z_OK;
}
if (s->level != level) {
s->level = level;
@@ -680,22 +606,19 @@
local void flush_pending(strm)
z_streamp strm;
{
- unsigned len;
- deflate_state *s = strm->state;
+ unsigned len = strm->state->pending;
- _tr_flush_bits(s);
- len = s->pending;
if (len > strm->avail_out) len = strm->avail_out;
if (len == 0) return;
- zmemcpy(strm->next_out, s->pending_out, len);
+ zmemcpy(strm->next_out, strm->state->pending_out, len);
strm->next_out += len;
- s->pending_out += len;
+ strm->state->pending_out += len;
strm->total_out += len;
strm->avail_out -= len;
- s->pending -= len;
- if (s->pending == 0) {
- s->pending_out = s->pending_buf;
+ strm->state->pending -= len;
+ if (strm->state->pending == 0) {
+ strm->state->pending_out = strm->state->pending_buf;
}
}
@@ -922,7 +845,7 @@
* flushes. For repeated and useless calls with Z_FINISH, we keep
* returning Z_STREAM_END instead of Z_BUF_ERROR.
*/
- } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
+ } else if (strm->avail_in == 0 && flush <= old_flush &&
flush != Z_FINISH) {
ERR_RETURN(strm, Z_BUF_ERROR);
}
@@ -988,7 +911,6 @@
if (s->lookahead == 0) {
s->strstart = 0;
s->block_start = 0L;
- s->insert = 0;
}
}
}
@@ -1086,12 +1008,12 @@
ss = source->state;
- zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
+ zmemcpy(dest, source, sizeof(z_stream));
ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
if (ds == Z_NULL) return Z_MEM_ERROR;
dest->state = (struct internal_state FAR *) ds;
- zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
+ zmemcpy(ds, ss, sizeof(deflate_state));
ds->strm = dest;
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
@@ -1107,8 +1029,8 @@
}
/* following zmemcpy do not work for 16-bit MSDOS */
zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
- zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
- zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
+ zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
+ zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
@@ -1143,9 +1065,10 @@
strm->avail_in -= len;
#ifdef GZIP
- if (strm->state->wrap == 2)
+ if (strm->state->wrap == 2) {
copy_with_crc(strm, buf, len);
- else
+ }
+ else
#endif
{
zmemcpy(buf, strm->next_in, len);
@@ -1178,7 +1101,6 @@
s->strstart = 0;
s->block_start = 0L;
s->lookahead = 0;
- s->insert = 0;
s->match_length = s->prev_length = MIN_MATCH-1;
s->match_available = 0;
s->ins_h = 0;
@@ -1450,7 +1372,7 @@
}
/* Check that we aren't matching a prefix of another cookie by ensuring
* that the final byte is either a semicolon (which cannot appear in a
- * cookie value), or non-cookie data. */
+ * cookie value), or the match is followed by non-cookie data. */
if (s->window[cookie_location+len-1] != ';' &&
class_at(s, cookie_location+len) != 0) {
return 0;
@@ -1584,8 +1506,6 @@
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);
@@ -1636,6 +1556,7 @@
*/
} while (--n);
#endif
+
for (n = 0; n < Z_COOKIE_HASH_SIZE; n++) {
if (s->cookie_locations[n] > wsize) {
s->cookie_locations[n] -= wsize;
@@ -1652,7 +1573,7 @@
more += wsize;
}
- if (s->strm->avail_in == 0) break;
+ if (s->strm->avail_in == 0) return;
/* If there was no sliding:
* strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
@@ -1674,24 +1595,12 @@
s->lookahead += n;
/* Initialize the hash value now that we have some input: */
- if (s->lookahead + s->insert >= MIN_MATCH) {
- uInt str = s->strstart - s->insert;
- s->ins_h = s->window[str];
- UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
+ if (s->lookahead >= MIN_MATCH) {
+ s->ins_h = s->window[s->strstart];
+ UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
#if MIN_MATCH != 3
Call UPDATE_HASH() MIN_MATCH-3 more times
#endif
- while (s->insert) {
- 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;
- str++;
- s->insert--;
- if (s->lookahead + s->insert < MIN_MATCH)
- break;
- }
}
/* 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.
@@ -1732,9 +1641,6 @@
s->high_water += init;
}
}
-
- Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
- "not enough room for search");
}
/* ===========================================================================
@@ -1815,14 +1721,8 @@
FLUSH_BLOCK(s, 0);
}
}
- s->insert = 0;
- if (flush == Z_FINISH) {
- FLUSH_BLOCK(s, 1);
- return finish_done;
- }
- if ((long)s->strstart > s->block_start)
- FLUSH_BLOCK(s, 0);
- return block_done;
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
}
/* ===========================================================================
@@ -1924,14 +1824,8 @@
}
if (bflush) FLUSH_BLOCK(s, 0);
}
- s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
- if (flush == Z_FINISH) {
- FLUSH_BLOCK(s, 1);
- return finish_done;
- }
- if (s->last_lit)
- FLUSH_BLOCK(s, 0);
- return block_done;
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
}
#ifndef FASTEST
@@ -2086,14 +1980,8 @@
_tr_tally_lit(s, s->window[s->strstart-1], bflush);
s->match_available = 0;
}
- s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
- if (flush == Z_FINISH) {
- FLUSH_BLOCK(s, 1);
- return finish_done;
- }
- if (s->last_lit)
- FLUSH_BLOCK(s, 0);
- return block_done;
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
}
#endif /* FASTEST */
@@ -2113,11 +2001,11 @@
for (;;) {
/* Make sure that we always have enough lookahead, except
* at the end of the input file. We need MAX_MATCH bytes
- * for the longest run, plus one for the unrolled loop.
+ * for the longest encodable run.
*/
- if (s->lookahead <= MAX_MATCH) {
+ if (s->lookahead < MAX_MATCH) {
fill_window(s);
- if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
+ if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
return need_more;
}
if (s->lookahead == 0) break; /* flush the current block */
@@ -2140,7 +2028,6 @@
if (s->match_length > s->lookahead)
s->match_length = s->lookahead;
}
- Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
}
/* Emit match if have run of MIN_MATCH or longer, else emit literal */
@@ -2161,14 +2048,8 @@
}
if (bflush) FLUSH_BLOCK(s, 0);
}
- s->insert = 0;
- if (flush == Z_FINISH) {
- FLUSH_BLOCK(s, 1);
- return finish_done;
- }
- if (s->last_lit)
- FLUSH_BLOCK(s, 0);
- return block_done;
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
}
/* ===========================================================================
@@ -2200,14 +2081,8 @@
s->strstart++;
if (bflush) FLUSH_BLOCK(s, 0);
}
- s->insert = 0;
- if (flush == Z_FINISH) {
- FLUSH_BLOCK(s, 1);
- return finish_done;
- }
- if (s->last_lit)
- FLUSH_BLOCK(s, 0);
- return block_done;
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
}
/* Safe to inline this as GCC/clang will use inline asm and Visual Studio will