deps: update zlib to 1.3.0.1-motley-40e35a7

PR-URL: #51274 Reviewed-By: Luigi Pinca <[email protected]> Reviewed-By: Michaël Zasso <[email protected]>

Author: nodejs-github-bot

deps/zlib/BUILD.gn

@@ -3,6 +3,7 @@
 # found in the LICENSE file.
 
 import("//build/config/compiler/compiler.gni")
+import("//build/config/dcheck_always_on.gni")
 
 declare_args(){
 # Expose zlib's symbols, used by Node.js to provide zlib APIs for its native
@@ -33,7 +34,7 @@ config("zlib_internal_config"){
 # Build code using -O3, see: crbug.com/1084371.
 configs= [ "//build/config/compiler:optimize_speed" ]
  }
-if (is_debug||use_fuzzing_engine){
+if (is_debug||dcheck_always_on||use_fuzzing_engine){
 # Enable zlib's asserts in debug and fuzzer builds.
 defines+= [ "ZLIB_DEBUG" ]
  }

deps/zlib/contrib/tests/utils_unittest.cc

@@ -1025,6 +1025,61 @@ TEST(ZlibTest, DeflateZFixedCorruption){
 0);
 }
 
+TEST(ZlibTest, DeflateCopy){
+// Check that deflateCopy() works.
+
+ z_stream stream1;
+ stream1.zalloc = Z_NULL;
+ stream1.zfree = Z_NULL;
+int ret =
+deflateInit(&stream1, Z_DEFAULT_COMPRESSION);
+ASSERT_EQ(ret, Z_OK);
+ std::vector<uint8_t> compressed(
+deflateBound(&stream1, strlen(zFixedCorruptionData)));
+ stream1.next_out = compressed.data();
+ stream1.avail_out = compressed.size();
+
+// Compress the first 1000 bytes.
+ stream1.next_in = (uint8_t*)zFixedCorruptionData;
+ stream1.avail_in = 1000;
+ ret = deflate(&stream1, Z_NO_FLUSH);
+ASSERT_EQ(ret, Z_OK);
+
+// Copy the stream state.
+ z_stream stream2;
+ ret = deflateCopy(&stream2, &stream1);
+ASSERT_EQ(ret, Z_OK);
+deflateEnd(&stream1);
+
+// Compress the remaining bytes.
+ stream2.next_in = (uint8_t*)zFixedCorruptionData + (1000 - stream2.avail_in);
+ stream2.avail_in = strlen(zFixedCorruptionData) - (1000 - stream2.avail_in);
+ ret = deflate(&stream2, Z_FINISH);
+ASSERT_EQ(ret, Z_STREAM_END);
+size_t compressed_sz = compressed.size() - stream2.avail_out;
+deflateEnd(&stream2);
+
+// Check that decompression is successful.
+ std::vector<uint8_t> decompressed(strlen(zFixedCorruptionData));
+ z_stream stream;
+ stream.zalloc = Z_NULL;
+ stream.zfree = Z_NULL;
+ ret = inflateInit(&stream);
+ASSERT_EQ(ret, Z_OK);
+ stream.next_in = compressed.data();
+ stream.avail_in = compressed_sz;
+ stream.next_out = decompressed.data();
+ stream.avail_out = decompressed.size();
+ ret = inflate(&stream, Z_FINISH);
+ASSERT_EQ(ret, Z_STREAM_END);
+inflateEnd(&stream);
+
+EXPECT_EQ(decompressed.size(), strlen(zFixedCorruptionData));
+EXPECT_EQ(
+memcmp(zFixedCorruptionData, decompressed.data(), decompressed.size()),
+0);
+}
+
 // TODO(gustavoa): make these tests run standalone.
 #ifndef CMAKE_STANDALONE_UNITTESTS
 

deps/zlib/deflate.c

@@ -1345,7 +1345,11 @@ int ZEXPORT deflateCopy(z_streamp dest, z_streamp source){
 ds->window= (Bytef*) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
 ds->prev= (Posf*) ZALLOC(dest, ds->w_size, sizeof(Pos));
 ds->head= (Posf*) ZALLOC(dest, ds->hash_size, sizeof(Pos));
+#ifdefLIT_MEM
+ds->pending_buf= (uchf*) ZALLOC(dest, ds->lit_bufsize, 5);
+#else
 ds->pending_buf= (uchf*) ZALLOC(dest, ds->lit_bufsize, 4);
+#endif
 
 if (ds->window==Z_NULL||ds->prev==Z_NULL||ds->head==Z_NULL||
 ds->pending_buf==Z_NULL){
@@ -1356,7 +1360,11 @@ int ZEXPORT deflateCopy(z_streamp dest, z_streamp source){
 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));
+#ifdefLIT_MEM
+zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->lit_bufsize*5);
+#else
 zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+#endif
 
 ds->pending_out=ds->pending_buf+ (ss->pending_out-ss->pending_buf);
 #ifdefLIT_MEM

deps/zlib/deflate.h

@@ -25,7 +25,7 @@
 
 /* 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 */
+#defineLIT_MEM
 
 /* ===========================================================================
  * Internal compression state.

deps/zlib/google/compression_utils.cc

@@ -4,7 +4,6 @@
 
 #include"third_party/zlib/google/compression_utils.h"
 
-#include"base/bit_cast.h"
 #include"base/check_op.h"
 #include"base/process/memory.h"
 #include"base/sys_byteorder.h"
@@ -24,8 +23,8 @@ bool GzipCompress(base::span<const char> input,
 // uLongf can be larger than size_t.
  uLongf compressed_size_long = static_cast<uLongf>(output_buffer_size);
 if (zlib_internal::GzipCompressHelper(
-base::bit_cast<Bytef*>(output_buffer), &compressed_size_long,
-base::bit_cast<const Bytef*>(input.data()),
+reinterpret_cast<Bytef*>(output_buffer), &compressed_size_long,
+reinterpret_cast<const Bytef*>(input.data()),
 static_cast<uLongf>(input.size()), malloc_fn, free_fn) != Z_OK){
 returnfalse;
  }
@@ -55,7 +54,7 @@ bool GzipCompress(base::span<const uint8_t> input, std::string* output){
 
 if (zlib_internal::GzipCompressHelper(
  compressed_data, &compressed_data_size,
-base::bit_cast<const Bytef*>(input.data()), input_size, nullptr,
+reinterpret_cast<const Bytef*>(input.data()), input_size, nullptr,
 nullptr) != Z_OK){
 free(compressed_data);
 returnfalse;
@@ -82,8 +81,8 @@ bool GzipUncompress(const std::string& input, std::string* output){
 
  uncompressed_output.resize(uncompressed_size);
 if (zlib_internal::GzipUncompressHelper(
-base::bit_cast<Bytef*>(uncompressed_output.data()),
- &uncompressed_size, base::bit_cast<const Bytef*>(input.data()),
+reinterpret_cast<Bytef*>(uncompressed_output.data()),
+ &uncompressed_size, reinterpret_cast<const Bytef*>(input.data()),
 static_cast<uLongf>(input.length())) == Z_OK){
  output->swap(uncompressed_output);
 returntrue;
@@ -102,8 +101,8 @@ bool GzipUncompress(base::span<const uint8_t> input,
 if (uncompressed_size > output.size())
 returnfalse;
 returnzlib_internal::GzipUncompressHelper(
-base::bit_cast<Bytef*>(output.data()), &uncompressed_size,
-base::bit_cast<const Bytef*>(input.data()),
+reinterpret_cast<Bytef*>(const_cast<uint8_t*>(output.data())),
+&uncompressed_size, reinterpret_cast<const Bytef*>(input.data()),
 static_cast<uLongf>(input.size())) == Z_OK;
 }
 
@@ -117,8 +116,8 @@ bool GzipUncompress(base::span<const uint8_t> input, std::string* output){
  uLongf uncompressed_size = GetUncompressedSize(input);
  output->resize(uncompressed_size);
 returnzlib_internal::GzipUncompressHelper(
-base::bit_cast<Bytef*>(output->data()), &uncompressed_size,
-base::bit_cast<const Bytef*>(input.data()),
+reinterpret_cast<Bytef*>(output->data()), &uncompressed_size,
+reinterpret_cast<const Bytef*>(input.data()),
 static_cast<uLongf>(input.size())) == Z_OK;
 }
 
@@ -128,7 +127,8 @@ uint32_t GetUncompressedSize(base::span<const char> compressed_data){
 
 uint32_tGetUncompressedSize(base::span<constuint8_t> compressed_data){
 returnzlib_internal::GetGzipUncompressedSize(
- base::bit_cast<Bytef*>(compressed_data.data()), compressed_data.size());
+reinterpret_cast<const Bytef*>(compressed_data.data()),
+ compressed_data.size());
 }
 
 } // namespace compression

deps/zlib/trees.c

@@ -938,7 +938,8 @@ local void compress_block(deflate_state *s, const ct_data *ltree,
 
 /* Check for no overlay of pending_buf on needed symbols */
 #ifdefLIT_MEM
-Assert(s->pending< (s->lit_bufsize << 1) +sx, "pendingBuf overflow");
+Assert(s->pending< (s->lit_bufsize << 1) + (sx << 1),
+"pendingBuf overflow");
 #else
 Assert(s->pending<s->lit_bufsize+sx, "pendingBuf overflow");
 #endif

src/zlib_version.h

@@ -2,5 +2,5 @@
 // Refer to tools/dep_updaters/update-zlib.sh
 #ifndefSRC_ZLIB_VERSION_H_
 #defineSRC_ZLIB_VERSION_H_
-#defineZLIB_VERSION "1.3.0.1-motley-dd5fc13"
+#defineZLIB_VERSION "1.3.0.1-motley-40e35a7"
 #endif// SRC_ZLIB_VERSION_H_