snappy 0.5.1-java → 0.5.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3c13bc6b72ceae5f5dcb06879dff05d6578ba1d49b958004f67d1f718a8b2fe
-  data.tar.gz: de0b570cae46150d338f2930cd712f7fb09f6449a17cf7a60bb51fdaac9f83d9
+  metadata.gz: ae5b7ee86b107cc63c631dd7f5bd8f6c3c1b529b9f1a6711a1a9bb77f62e3cce
+  data.tar.gz: 24520d57dedb0ecba6811fc91829edcfbed06c4acafbf047d11b5c59e9b0c068
 SHA512:
-  metadata.gz: 96a873bc0a17c8b3a591286092d4ff2882ee542dedb062fe29695bd02036c961c9b8fc4b82623fc9e9ba9ebd9798e57a815ad86fa671b24fd0e2e28a1029e042
-  data.tar.gz: 251a267ed244d386a2ffdf4c710648aa6ef6950a44d0f5ab48365f34c7881e8aa85e101be91ec81e39857688ddd11fc5ba389d894545715fdbfbfec1916f6134
+  metadata.gz: e9dc63637f9c75a90a199a6ab364964337a1383ceea72c4d5bcdbb9dd6a05aab3da96bfae440b52d9c6164b14cd84e5a92b8f77a5258d6a5e7166b4578a6caeb
+  data.tar.gz: 7582e5bffc506c2789d689bb1f06773dab8d84489720822e20c61a15c9f4d02bd3833857e243339b5d9105e459c5b8a3e17a573ea51f98eeef5d30aa55d1fd54

data/ext/api.c

@@ -1,6 +1,8 @@
 #include "ruby.h"
 #include "snappy-c.h"
 
+#define SNAPPY_MAX_EXPANSION 22
+
 static VALUE rb_eSnappy;
 
 static VALUE
@@ -59,6 +61,13 @@ snappy_inflate(int argc, VALUE *argv, VALUE self)
         return snappy_raise(result);
     }
 
+    /* The header is untrusted. No element expands by more than 64/3
+     * (a 3-byte copy of 64 bytes), so a larger claim cannot be valid and
+     * must not decide the allocation size. */
+    if (output_length / SNAPPY_MAX_EXPANSION > (size_t)RSTRING_LEN(src)) {
+        return snappy_raise(SNAPPY_INVALID_INPUT);
+    }
+
     if (NIL_P(dst)) {
         dst = rb_str_new(NULL, output_length);
     } else {

data/lib/snappy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Snappy
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/snappy.gemspec

@@ -21,7 +21,8 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0")
   spec.files        -= spec.test_files
   spec.files        -= ["vendor/snappy"]
-  spec.files        += Dir["vendor/snappy/**/*"].reject { |e| e.start_with? "vendor/snappy/testdata" }
+  # third_party is only for snappy's own tests/benchmarks, and build is cmake output left by extconf.rb
+  spec.files        += Dir["vendor/snappy/**/*"].reject { |e| e.start_with?(*%w[testdata third_party build].map { |d| "vendor/snappy/#{d}" }) }
 
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/test/snappy_test.rb

@@ -59,6 +59,23 @@ class SnappyTest < Test::Unit::TestCase
       r = Snappy.inflate(s, d)
       assert_equal r.object_id, d.object_id
     end
+
+    test "reject a header that claims more than the input can expand to" do
+      if defined? JRUBY_VERSION
+        notify "cannot pass buffer in jruby"
+        omit
+      end
+      # varint header claiming 0xFFFFFFFF bytes, with no elements behind it
+      s = "\xFF\xFF\xFF\xFF\x0F".b
+      d = +""
+      assert_raise(Snappy::Error) { Snappy.inflate(s, d) }
+      assert_equal 0, d.bytesize
+    end
+
+    test "inflate data compressed at the maximum ratio" do
+      s = "\0" * (1024 * 1024)
+      assert_equal s, Snappy.inflate(Snappy.deflate(s))
+    end
   end
 
   sub_test_case ".valid?" do

data/vendor/snappy/BUILD.bazel

@@ -26,11 +26,21 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+load("@bazel_skylib//rules:expand_template.bzl", "expand_template")
+load("@bazel_skylib//rules:write_file.bzl", "write_file")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
+
 package(default_visibility = ["//visibility:public"])
 
 licenses(["notice"])
 
-SNAPPY_VERSION = (1, 2, 2)
+exports_files([
+    "COPYING",
+    "COPYING.notestdata",
+])
+
+SNAPPY_VERSION = (1, 3, 1)
 
 config_setting(
     name = "windows",
@@ -52,8 +62,10 @@ cc_library(
     name = "snappy-stubs-internal",
     srcs = ["snappy-stubs-internal.cc"],
     hdrs = ["snappy-stubs-internal.h"],
-    deps = [
+    implementation_deps = [
         ":config",
+    ],
+    deps = [
         ":snappy-stubs-public",
     ],
 )
@@ -75,8 +87,10 @@ cc_library(
             "-Wno-sign-compare",
         ],
     }),
-    deps = [
+    implementation_deps = [
         ":config",
+    ],
+    deps = [
         ":snappy-stubs-internal",
         ":snappy-stubs-public",
     ],
@@ -133,10 +147,10 @@ cc_test(
 )
 
 # Generate a config.h similar to what cmake would produce.
-genrule(
+write_file(
     name = "config_h",
-    outs = ["config.h"],
-    cmd = """cat <<EOF >$@
+    out = "config.h",
+    content = """\
 #define HAVE_STDDEF_H 1
 #define HAVE_STDINT_H 1
 #ifdef __has_builtin
@@ -193,19 +207,17 @@ genrule(
 #    define SNAPPY_IS_BIG_ENDIAN 1
 #  endif
 #endif
-EOF
-""",
+""".splitlines(),
 )
 
-genrule(
+expand_template(
     name = "snappy_stubs_public_h",
-    srcs = ["snappy-stubs-public.h.in"],
-    outs = ["snappy-stubs-public.h"],
-    # Assume sys/uio.h is available on non-Windows.
-    # Set the version numbers.
-    cmd = ("""sed -e 's/$${HAVE_SYS_UIO_H_01}/!_WIN32/g' \
-           -e 's/$${PROJECT_VERSION_MAJOR}/%d/g' \
-           -e 's/$${PROJECT_VERSION_MINOR}/%d/g' \
-           -e 's/$${PROJECT_VERSION_PATCH}/%d/g' \
-    $< >$@""" % SNAPPY_VERSION),
+    out = "snappy-stubs-public.h",
+    substitutions = {
+        "${HAVE_SYS_UIO_H_01}": "!_WIN32",
+        "${PROJECT_VERSION_MAJOR}": str(SNAPPY_VERSION[0]),
+        "${PROJECT_VERSION_MINOR}": str(SNAPPY_VERSION[1]),
+        "${PROJECT_VERSION_PATCH}": str(SNAPPY_VERSION[2]),
+    },
+    template = "snappy-stubs-public.h.in",
 )

data/vendor/snappy/CMakeLists.txt

@@ -27,7 +27,12 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 cmake_minimum_required(VERSION 3.10)
-project(Snappy VERSION 1.2.2 LANGUAGES C CXX)
+
+if(POLICY CMP0091)
+  cmake_policy(SET CMP0091 NEW)
+endif()
+
+project(Snappy VERSION 1.3.1 LANGUAGES C CXX)
 
 # C++ standard can be overridden when this is used as a sub-project.
 if(NOT CMAKE_CXX_STANDARD)
@@ -55,6 +60,21 @@ if(MSVC)
   # Disable RTTI.
   string(REGEX REPLACE "/GR" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
+
+  # Support static MSVC runtime when building static library.
+  option(SNAPPY_MSVC_STATIC_RUNTIME "Link to static MSVC runtime (/MT or /MTd)" OFF)
+  if(SNAPPY_MSVC_STATIC_RUNTIME)
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    foreach(flag_var
+        CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+        CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+      if(${flag_var} MATCHES "/MD")
+        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+      endif()
+    endforeach()
+  endif()
 else(MSVC)
   # Use -Wall for clang and gcc.
   if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
@@ -155,10 +175,20 @@ int main() {
   return __builtin_expect(0, 1);
 }" HAVE_BUILTIN_EXPECT)
 
+# Check if the built-in __builtin_ctz (count trailing zeros) is available.
+# Require either a non-RISC-V target, or a RISC-V core that implements
+# the Zbb bit-manipulation extension where ctz is guaranteed.
 check_cxx_source_compiles("
-int main() {
-  return __builtin_ctzll(0);
-}" HAVE_BUILTIN_CTZ)
+#ifdef __riscv
+  #ifdef __riscv_zbb
+    int main() { return __builtin_ctzll(0); }
+  #else
+    #error \"ZBB not enabled in current config\"
+  #endif
+#else
+  int main() { return __builtin_ctzll(0); }
+#endif
+" HAVE_BUILTIN_CTZ)
 
 check_cxx_source_compiles("
 int main() {
@@ -216,6 +246,31 @@ int main() {
   return 0;
 }" SNAPPY_HAVE_NEON)
 
+#check RVV 1.0 need __riscv_ prefix
+check_cxx_source_compiles("
+  #include <riscv_vector.h>
+  #include <stdint.h>
+  #include <stddef.h>
+  int main() {
+    uint8_t val = 3, dup[8];
+    size_t vl = __riscv_vsetvl_e8m1(8);
+    vuint8m1_t v = __riscv_vmv_v_x_u8m1(val, vl);
+    return 0;
+  }" SNAPPY_RVV_1)
+
+
+#check RVV 0.7.1 not  __riscv_ prefix
+check_cxx_source_compiles("
+  #include <riscv_vector.h>
+  #include <stdint.h>
+  #include <stddef.h>
+  int main() {
+    uint8_t val = 3, dup[8];
+    size_t vl = vsetvl_e8m1(8);
+    vuint8m1_t v = vmv_v_x_u8m1(val, vl);
+    return 0;
+  }" SNAPPY_RVV_0_7)
+
 include(CheckSymbolExists)
 check_symbol_exists("mmap" "sys/mman.h" HAVE_FUNC_MMAP)
 check_symbol_exists("sysconf" "unistd.h" HAVE_FUNC_SYSCONF)
@@ -251,6 +306,9 @@ configure_file(
   "snappy-stubs-public.h.in"
   "${PROJECT_BINARY_DIR}/snappy-stubs-public.h")
 
+# Must be included before CMAKE_INSTALL_INCLUDEDIR is used.
+include(GNUInstallDirs)
+
 add_library(snappy "")
 target_sources(snappy
   PRIVATE
@@ -263,19 +321,19 @@ target_sources(snappy
     "${PROJECT_BINARY_DIR}/config.h"
   PUBLIC
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-c.h>
-    $<INSTALL_INTERFACE:include/snappy-c.h>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/snappy-c.h>
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-sinksource.h>
-    $<INSTALL_INTERFACE:include/snappy-sinksource.h>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/snappy-sinksource.h>
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy.h>
-    $<INSTALL_INTERFACE:include/snappy.h>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/snappy.h>
     $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/snappy-stubs-public.h>
-    $<INSTALL_INTERFACE:include/snappy-stubs-public.h>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/snappy-stubs-public.h>
 )
 target_include_directories(snappy
   PUBLIC
     $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 set_target_properties(snappy
   PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR})
@@ -399,9 +457,6 @@ if(SNAPPY_FUZZING_BUILD)
   )
 endif(SNAPPY_FUZZING_BUILD)
 
-# Must be included before CMAKE_INSTALL_INCLUDEDIR is used.
-include(GNUInstallDirs)
-
 if(SNAPPY_INSTALL)
   install(TARGETS snappy
     EXPORT SnappyTargets

data/vendor/snappy/COPYING.notestdata

@@ -0,0 +1,28 @@
+Copyright 2011, Google Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/snappy/MODULE.bazel

@@ -1,23 +1,26 @@
 module(
     name = "snappy",
-    version = "1.2.2",
+    version = "1.3.1",
     compatibility_level = 1,
 )
 
+bazel_dep(name = "rules_cc", version = "0.2.4")
+bazel_dep(name = "bazel_skylib", version = "1.8.2")
+
 bazel_dep(
     name = "googletest",
-    version = "1.14.0.bcr.1",
+    version = "1.17.0.bcr.2",
     dev_dependency = True,
     repo_name = "com_google_googletest",
 )
 bazel_dep(
     name = "google_benchmark",
-    version = "1.9.0",
+    version = "1.9.5",
     dev_dependency = True,
     repo_name = "com_google_benchmark",
 )
 
 bazel_dep(
     name = "platforms",
-    version = "0.0.9",
+    version = "1.0.0",
 )

data/vendor/snappy/NEWS

@@ -1,3 +1,15 @@
+Snappy v1.3.1, Sep 18th 2026:
+
+   * Fixed a uint32_t overflow when decompressor accepted an input with incorrect format
+
+   * Significant RISC-V efficiency improvements
+
+   * New API on providing your own memory context
+
+   * Supporting compression levels (1-2) in C API
+
+   * Various other small fixes
+
 Snappy v1.2.2, Mar 26th 2025:
 
   * We added a new compression level in v1.2.1 which compresses a bit

data/vendor/snappy/README.md

@@ -75,6 +75,10 @@ mkdir build
 cd build && cmake ../ && make
 ```
 
+MSVC users must manually set `SNAPPY_HAVE_SSSE3`, `SNAPPY_HAVE_X86_CRC32`,
+`SNAPPY_HAVE_BMI2`, `SNAPPY_HAVE_NEON_CRC32`, and `SNAPPY_HAVE_NEON` due to
+MSVC's incorrect architecture detection, if using pre-`/arch:AVX2`.
+
 Usage
 =====
 
@@ -140,10 +144,10 @@ explicitly supports the following:
 1. C++11
 2. Clang (gcc and MSVC are best-effort).
 3. Low level optimizations (e.g. assembly or equivalent intrinsics) for:
-     - [x86](https://en.wikipedia.org/wiki/X86)
-     - [x86-64](https://en.wikipedia.org/wiki/X86-64)
-     - ARMv7 (32-bit)
-     - ARMv8 (AArch64)
+      - [x86](https://en.wikipedia.org/wiki/X86)
+      - [x86-64](https://en.wikipedia.org/wiki/X86-64)
+      - ARMv7 (32-bit)
+      - ARMv8 (AArch64)
 4. Supports only the Snappy compression scheme as described in
   [format_description.txt](format_description.txt).
 5. CMake for building

data/vendor/snappy/cmake/config.h.in

@@ -58,6 +58,12 @@
 /* Define to 1 if you target processors with NEON and have <arm_neon.h>. */
 #cmakedefine01 SNAPPY_HAVE_NEON
 
+/* Define to 1 if you target processors with RVV1.0 and have <riscv_vector.h>. */
+#cmakedefine01 SNAPPY_RVV_1
+
+/* Define to 1 if you target processors with RVV0.7 and have <riscv_vector.h>. */
+#cmakedefine01 SNAPPY_RVV_0_7
+
 /* Define to 1 if you have <arm_neon.h> and <arm_acle.h> and want to optimize
    compression speed by using __crc32cw from <arm_acle.h>. */
 #cmakedefine01 SNAPPY_HAVE_NEON_CRC32

data/vendor/snappy/format_description.txt

@@ -22,7 +22,8 @@ stored as a little-endian varint. Varints consist of a series of bytes,
 where the lower 7 bits are data and the upper bit is set iff there are
 more bytes to be read. In other words, an uncompressed length of 64 would
 be stored as 0x40, and an uncompressed length of 2097150 (0x1FFFFE)
-would be stored as 0xFE 0xFF 0x7F.
+would be stored as 0xFE 0xFF 0x7F. Given the maximum, 5 bytes are sufficient for
+any value.
 
 
 2. The compressed stream itself

data/vendor/snappy/snappy-c.cc

@@ -39,6 +39,28 @@ snappy_status snappy_compress(const char* input,
     return SNAPPY_BUFFER_TOO_SMALL;
   }
   snappy::RawCompress(input, input_length, compressed, compressed_length);
+  if (*compressed_length == 0) {
+    return SNAPPY_INVALID_INPUT;
+  }
+  return SNAPPY_OK;
+}
+
+snappy_status snappy_compress_with_level(const char* input, size_t input_length,
+                                         int compression_level,
+                                         char* compressed,
+                                         size_t* compressed_length) {
+  if (*compressed_length < snappy_max_compressed_length(input_length)) {
+    return SNAPPY_BUFFER_TOO_SMALL;
+  }
+  if (compression_level < SNAPPY_MIN_COMPRESSION_LEVEL ||
+      compression_level > SNAPPY_MAX_COMPRESSION_LEVEL) {
+    return SNAPPY_INVALID_INPUT;
+  }
+  snappy::RawCompress(input, input_length, compressed, compressed_length,
+                      snappy::CompressionOptions{/*level=*/compression_level});
+  if (*compressed_length == 0) {
+    return SNAPPY_INVALID_INPUT;
+  }
   return SNAPPY_OK;
 }
 

data/vendor/snappy/snappy-c.h

@@ -57,7 +57,11 @@ typedef enum {
  * If it is not at least equal to "snappy_max_compressed_length(input_length)",
  * SNAPPY_BUFFER_TOO_SMALL is returned. After successful compression,
  * <compressed_length> contains the true length of the compressed output,
- * and SNAPPY_OK is returned.
+ * and SNAPPY_OK is returned. Compression level is 1. For using other
+ * compression levels, call snappy_compress_with_level.
+ *
+ * An <input_length> of 2^32 or more returns SNAPPY_INVALID_INPUT with
+ * <compressed_length> set to 0 and nothing written.
  *
  * Example:
  *   size_t output_length = snappy_max_compressed_length(input_length);
@@ -68,10 +72,20 @@ typedef enum {
  *   }
  *   free(output);
  */
-snappy_status snappy_compress(const char* input,
-                              size_t input_length,
-                              char* compressed,
-                              size_t* compressed_length);
+snappy_status snappy_compress(const char* input, size_t input_length,
+                              char* compressed, size_t* compressed_length);
+
+/*
+ * Same as above but uses compression_level which must be between
+ * SNAPPY_MIN_COMPRESSION_LEVEL and SNAPPY_MAX_COMPRESSION_LEVEL.
+ */
+#define SNAPPY_MIN_COMPRESSION_LEVEL 1
+#define SNAPPY_MAX_COMPRESSION_LEVEL 2
+
+snappy_status snappy_compress_with_level(const char* input, size_t input_length,
+                                         int compression_level,
+                                         char* compressed,
+                                         size_t* compressed_length);
 
 /*
  * Given data in "compressed[0..compressed_length-1]" generated by

data/vendor/snappy/snappy-internal.h

@@ -46,6 +46,19 @@
 #include <arm_neon.h>
 #endif
 
+#if SNAPPY_RVV_1 || SNAPPY_RVV_0_7
+#define SNAPPY_HAVE_RVV 1
+#include <riscv_vector.h>
+#else
+#define SNAPPY_HAVE_RVV 0
+#endif
+
+#if SNAPPY_RVV_1 || SNAPPY_RVV_0_7
+#define VSETVL_E8M2 __riscv_vsetvl_e8m2
+#define VLE8_V_U8M2 __riscv_vle8_v_u8m2
+#define VSE8_V_U8M2 __riscv_vse8_v_u8m2
+#endif
+
 #if SNAPPY_HAVE_SSSE3 || SNAPPY_HAVE_NEON
 #define SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE 1
 #else
@@ -110,6 +123,8 @@ inline V128 V128_Shuffle(V128 input, V128 shuffle_mask) {
 }
 
 inline V128 V128_DupChar(char c) { return vdupq_n_u8(c); }
+
+
 #endif
 #endif  // SNAPPY_HAVE_VECTOR_BYTE_SHUFFLE
 
@@ -118,8 +133,16 @@ inline V128 V128_DupChar(char c) { return vdupq_n_u8(c); }
 class WorkingMemory {
  public:
   explicit WorkingMemory(size_t input_size);
+
+  // Non-allocating: lays out the scratch space in the caller-provided
+  // buffer, which must be at least RequiredSize(input_size) bytes, aligned
+  // at least as strictly as uint16_t, and must outlive "*this".
+  WorkingMemory(size_t input_size, char* buffer);
   ~WorkingMemory();
 
+  // The buffer size required by the non-allocating constructor above.
+  static size_t RequiredSize(size_t input_size);
+
   // Allocates and clears a hash table using memory in "*this",
   // stores the number of buckets in "*table_size" and returns a pointer to
   // the base of the hash table.
@@ -130,6 +153,7 @@ class WorkingMemory {
  private:
   char* mem_;        // the allocated memory, never nullptr
   size_t size_;      // the size of the allocated memory, never 0
+  bool owns_mem_;
   uint16_t* table_;  // the pointer to the hashtable
   char* input_;      // the pointer to the input scratch buffer
   char* output_;     // the pointer to the output scratch buffer
@@ -172,9 +196,10 @@ char* CompressFragment(const char* input,
 // loading from s2 + n.
 //
 // Separate implementation for 64-bit, little-endian cpus.
+// riscv and little-endian cpu choose this routinue can be done faster too.
 #if !SNAPPY_IS_BIG_ENDIAN && \
     (defined(__x86_64__) || defined(_M_X64) || defined(ARCH_PPC) || \
-     defined(ARCH_ARM))
+     defined(__aarch64__) || (defined(__riscv) && (__riscv_xlen == 64)))
 static inline std::pair<size_t, bool> FindMatchLength(const char* s1,
                                                       const char* s2,
                                                       const char* s2_limit,

data/vendor/snappy/snappy-stubs-internal.h

@@ -304,6 +304,7 @@ class Bits {
   void operator=(const Bits&);
 };
 
+// In RISC-V,  CLZ  is supported by instructions from the ZBB bit-manipulation extension.
 #if HAVE_BUILTIN_CTZ
 
 inline int Bits::Log2FloorNonZero(uint32_t n) {
@@ -393,6 +394,7 @@ inline int Bits::FindLSBSetNonZero(uint32_t n) {
 
 #endif  // End portable versions.
 
+// In RISC-V,  CLZ  is supported by instructions from the ZBB bit-manipulation extension.
 #if HAVE_BUILTIN_CTZ
 
 inline int Bits::FindLSBSetNonZero64(uint64_t n) {

data/vendor/snappy/snappy-test.cc

@@ -464,7 +464,8 @@ bool ZLib::UncompressChunkDone() {
   // Make sure we're at the end-of-compressed-data point.  This means
   // if we call inflate with Z_FINISH we won't consume any input or
   // write any output
-  Bytef dummyin, dummyout;
+  Bytef dummyout;
+  Bytef dummyin = 0;
   uLongf dummylen = 0;
   if ( UncompressChunkOrAll(&dummyout, &dummylen, &dummyin, 0, Z_FINISH)
        != Z_OK ) {