deps: update zlib to 1.3.0.1-motley-dd5fc13

PR-URL: #51105 Reviewed-By: Luigi Pinca <[email protected]> Reviewed-By: Marco Ippolito <[email protected]>

Author: nodejs-github-bot

deps/zlib/CMakeLists.txt

@@ -3,7 +3,7 @@ set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
 
 project(zlib C)
 
-set(VERSION"1.3")
+set(VERSION"1.3.0.1")
 
 set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin"CACHEPATH"Installation directory for executables")
 set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib"CACHEPATH"Installation directory for libraries")

deps/zlib/README.chromium

@@ -1,8 +1,8 @@
 Name: zlib
 Short Name: zlib
 URL: http://zlib.net/
-Version: 1.2.13
-CPEPrefix: cpe:/a:zlib:zlib:1.2.13
+Version: 1.3.0.1
+CPEPrefix: cpe:/a:zlib:zlib:1.3.0.1
 Security Critical: yes
 Shipped: yes
 License: Zlib

deps/zlib/contrib/minizip/README.chromium

@@ -6,6 +6,7 @@ License: Zlib
 License File: //third_party/zlib/LICENSE
 Security Critical: yes
 Shipped: yes
+CPEPrefix: cpe:/a:minizip_project:minizip
 
 Description:
 Minizip provides API on top of zlib that can enumerate and extract ZIP archive

deps/zlib/contrib/optimizations/inflate.c

@@ -1422,7 +1422,7 @@ int ZEXPORT inflateSync(z_streamp strm){
 /* if first time, start search in bit buffer */
 if (state->mode!=SYNC){
 state->mode=SYNC;
-state->hold<<= state->bits&7;
+state->hold>>= state->bits&7;
 state->bits-=state->bits&7;
 len=0;
 while (state->bits >= 8){

deps/zlib/deflate.c

@@ -65,7 +65,7 @@
 #endif
 
 constchardeflate_copyright[] =
-" deflate 1.3 Copyright 1995-2023 Jean-loup Gailly and Mark Adler ";
+" deflate 1.3.0.1 Copyright 1995-2023 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
@@ -531,7 +531,11 @@ int ZEXPORT deflateInit2_(z_streamp strm, int level, int method,
  * the compressed data for a dynamic block also cannot overwrite the
  * symbols from which it is being constructed.
  */
+#ifdefLIT_MEM
+s->pending_buf= (uchf*) ZALLOC(strm, s->lit_bufsize, 5);
+#else
 s->pending_buf= (uchf*) ZALLOC(strm, s->lit_bufsize, 4);
+#endif
 s->pending_buf_size= (ulg)s->lit_bufsize*4;
 
 if (s->window==Z_NULL||s->prev==Z_NULL||s->head==Z_NULL||
@@ -541,8 +545,14 @@ int ZEXPORT deflateInit2_(z_streamp strm, int level, int method,
 deflateEnd (strm);
 returnZ_MEM_ERROR;
  }
+#ifdefLIT_MEM
+s->d_buf= (ushf*)(s->pending_buf+ (s->lit_bufsize << 1));
+s->l_buf=s->pending_buf+ (s->lit_bufsize << 2);
+s->sym_end=s->lit_bufsize-1;
+#else
 s->sym_buf=s->pending_buf+s->lit_bufsize;
 s->sym_end= (s->lit_bufsize-1) *3;
+#endif
 /* We avoid equality with lit_bufsize*3 because of wraparound at 64K
  * on 16 bit machines and because stored blocks are restricted to
  * 64K-1 bytes.
@@ -754,9 +764,15 @@ int ZEXPORT deflatePrime(z_streamp strm, int bits, int value){
 
 if (deflateStateCheck(strm)) returnZ_STREAM_ERROR;
 s=strm->state;
+#ifdefLIT_MEM
+if (bits<0||bits>16||
+ (uchf*)s->d_buf<s->pending_out+ ((Buf_size+7) >> 3))
+returnZ_BUF_ERROR;
+#else
 if (bits<0||bits>16||
 s->sym_buf<s->pending_out+ ((Buf_size+7) >> 3))
 returnZ_BUF_ERROR;
+#endif
 do{
 put=Buf_size-s->bi_valid;
 if (put>bits)
@@ -1343,7 +1359,12 @@ int ZEXPORT deflateCopy(z_streamp dest, z_streamp source){
 zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
 
 ds->pending_out=ds->pending_buf+ (ss->pending_out-ss->pending_buf);
+#ifdefLIT_MEM
+ds->d_buf= (ushf*)(ds->pending_buf+ (ds->lit_bufsize << 1));
+ds->l_buf=ds->pending_buf+ (ds->lit_bufsize << 2);
+#else
 ds->sym_buf=ds->pending_buf+ds->lit_bufsize;
+#endif
 
 ds->l_desc.dyn_tree=ds->dyn_ltree;
 ds->d_desc.dyn_tree=ds->dyn_dtree;

deps/zlib/deflate.h

@@ -23,6 +23,10 @@
 # defineGZIP
 #endif
 
+/* define LIT_MEM to slightly increase the speed of deflate (order 1% to 2%) at
+ the cost of a larger memory footprint */
+/* #define LIT_MEM */
+
 /* ===========================================================================
  * Internal compression state.
  */
@@ -217,7 +221,12 @@ typedef struct internal_state{
 /* Depth of each subtree used as tie breaker for trees of equal frequency
  */
 
+#ifdefLIT_MEM
+ushf*d_buf; /* buffer for distances */
+uchf*l_buf; /* buffer for literals/lengths */
+#else
 uchf*sym_buf; /* buffer for distances and literals/lengths */
+#endif
 
 uIntlit_bufsize;
 /* Size of match buffer for literals/lengths. There are 4 reasons for
@@ -239,7 +248,7 @@ typedef struct internal_state{
  * - I can't count above 4
  */
 
-uIntsym_next; /* running index in sym_buf */
+uIntsym_next; /* running index in symbol buffer */
 uIntsym_end; /* symbol table full when sym_next reaches this */
 
 ulgopt_len; /* bit length of current block with optimal trees */
@@ -323,6 +332,25 @@ void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf,
 externconstuchZLIB_INTERNAL_dist_code[];
 #endif
 
+#ifdefLIT_MEM
+# define_tr_tally_lit(s, c, flush) \
+{uch cc = (c); \
+ s->d_buf[s->sym_next] = 0; \
+ s->l_buf[s->sym_next++] = cc; \
+ s->dyn_ltree[cc].Freq++; \
+ flush = (s->sym_next == s->sym_end); \
+ }
+# define_tr_tally_dist(s, distance, length, flush) \
+{uch len = (uch)(length); \
+ ush dist = (ush)(distance); \
+ s->d_buf[s->sym_next] = dist; \
+ s->l_buf[s->sym_next++] = len; \
+ dist--; \
+ s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+ s->dyn_dtree[d_code(dist)].Freq++; \
+ flush = (s->sym_next == s->sym_end); \
+ }
+#else
 # define_tr_tally_lit(s, c, flush) \
 {uch cc = (c); \
  s->sym_buf[s->sym_next++] = 0; \
@@ -342,6 +370,7 @@ void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf,
  s->dyn_dtree[d_code(dist)].Freq++; \
  flush = (s->sym_next == s->sym_end); \
  }
+#endif
 #else
 # define_tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
 # define_tr_tally_dist(s, distance, length, flush) \

deps/zlib/inflate.c

@@ -1389,7 +1389,7 @@ int ZEXPORT inflateSync(z_streamp strm){
 /* if first time, start search in bit buffer */
 if (state->mode!=SYNC){
 state->mode=SYNC;
-state->hold<<= state->bits&7;
+state->hold>>= state->bits&7;
 state->bits-=state->bits&7;
 len=0;
 while (state->bits >= 8){

deps/zlib/inftrees.c

@@ -9,7 +9,7 @@
 #defineMAXBITS 15
 
 constcharinflate_copyright[] =
-" inflate 1.3 Copyright 1995-2023 Mark Adler ";
+" inflate 1.3.0.1 Copyright 1995-2023 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
@@ -57,7 +57,7 @@ int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens,
 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
 staticconstunsigned shortlext[31] ={/* Length codes 257..285 extra */
 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 198, 203};
+19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 70, 200};
 staticconstunsigned shortdbase[32] ={/* Distance codes 0..29 base */
 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,

deps/zlib/trees.c

@@ -899,14 +899,19 @@ local void compress_block(deflate_state *s, const ct_data *ltree,
 constct_data*dtree){
 unsigneddist; /* distance of matched string */
 intlc; /* match length or unmatched char (if dist == 0) */
-unsignedsx=0; /* running index in sym_buf */
+unsignedsx=0; /* running index in symbol buffers */
 unsignedcode; /* the code to send */
 intextra; /* number of extra bits to send */
 
 if (s->sym_next!=0) do{
+#ifdefLIT_MEM
+dist=s->d_buf[sx];
+lc=s->l_buf[sx++];
+#else
 dist=s->sym_buf[sx++] &0xff;
 dist+= (unsigned)(s->sym_buf[sx++] &0xff) << 8;
 lc=s->sym_buf[sx++];
+#endif
 if (dist==0){
 send_code(s, lc, ltree); /* send a literal byte */
 Tracecv(isgraph(lc), (stderr," '%c' ", lc));
@@ -931,8 +936,12 @@ local void compress_block(deflate_state *s, const ct_data *ltree,
  }
  } /* literal or match pair ? */
 
-/* Check that the overlay between pending_buf and sym_buf is ok: */
+/* Check for no overlay of pending_buf on needed symbols */
+#ifdefLIT_MEM
+Assert(s->pending< (s->lit_bufsize << 1) +sx, "pendingBuf overflow");
+#else
 Assert(s->pending<s->lit_bufsize+sx, "pendingBuf overflow");
+#endif
 
  } while (sx<s->sym_next);
 
@@ -1082,9 +1091,14 @@ void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf,
  * the current block must be flushed.
  */
 intZLIB_INTERNAL_tr_tally(deflate_state*s, unsigneddist, unsignedlc){
+#ifdefLIT_MEM
+s->d_buf[s->sym_next] = (ush)dist;
+s->l_buf[s->sym_next++] = (uch)lc;
+#else
 s->sym_buf[s->sym_next++] = (uch)dist;
 s->sym_buf[s->sym_next++] = (uch)(dist >> 8);
 s->sym_buf[s->sym_next++] = (uch)lc;
+#endif
 if (dist==0){
 /* lc is the unmatched char */
 s->dyn_ltree[lc].Freq++;

deps/zlib/zlib.3

@@ -1,4 +1,4 @@
-.TH ZLIB 3 "xx Oct 2022"
+.TH ZLIB 3 "xx Aug 2023"
 .SH NAME
 zlib \- compression/decompression library
 .SH SYNOPSIS
@@ -105,7 +105,7 @@ before asking for help.
 Send questions and/or comments to [email protected],
 or (for the Windows DLL version) to Gilles Vollant ([email protected]).
 .SH AUTHORS AND LICENSE
-Version 1.2.13.1
+Version 1.2.3.0.1
 .LP
 Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler
 .LP