brotli 0.2.3 → 0.4.0

data/vendor/brotli/c/enc/entropy_encode.c

@@ -18,6 +18,8 @@
 extern "C" {
 #endif
 
+const size_t kBrotliShellGaps[] = {132, 57, 23, 10, 4, 1};
+
 BROTLI_BOOL BrotliSetDepth(
     int p0, HuffmanTree* pool, uint8_t* depth, int max_depth) {
   int stack[16];

data/vendor/brotli/c/enc/entropy_encode.h

@@ -76,12 +76,12 @@ BROTLI_INTERNAL void BrotliConvertBitDepthsToSymbols(const uint8_t* depth,
                                                      size_t len,
                                                      uint16_t* bits);
 
+BROTLI_INTERNAL extern const size_t kBrotliShellGaps[6];
 /* Input size optimized Shell sort. */
 typedef BROTLI_BOOL (*HuffmanTreeComparator)(
     const HuffmanTree*, const HuffmanTree*);
 static BROTLI_INLINE void SortHuffmanTreeItems(HuffmanTree* items,
     const size_t n, HuffmanTreeComparator comparator) {
-  static const size_t gaps[] = {132, 57, 23, 10, 4, 1};
   if (n < 13) {
     /* Insertion sort. */
     size_t i;
@@ -101,7 +101,7 @@ static BROTLI_INLINE void SortHuffmanTreeItems(HuffmanTree* items,
     /* Shell sort. */
     int g = n < 57 ? 2 : 0;
     for (; g < 6; ++g) {
-      size_t gap = gaps[g];
+      size_t gap = kBrotliShellGaps[g];
       size_t i;
       for (i = gap; i < n; ++i) {
         size_t j = i;

data/vendor/brotli/c/enc/fast_log.c

@@ -0,0 +1,105 @@
+/* Copyright 2013 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+#include "./fast_log.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/* ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]]) */
+const double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE] = {
+  0.0000000000000000f, 0.0000000000000000f, 1.0000000000000000f,
+  1.5849625007211563f, 2.0000000000000000f, 2.3219280948873622f,
+  2.5849625007211561f, 2.8073549220576042f, 3.0000000000000000f,
+  3.1699250014423126f, 3.3219280948873626f, 3.4594316186372978f,
+  3.5849625007211565f, 3.7004397181410922f, 3.8073549220576037f,
+  3.9068905956085187f, 4.0000000000000000f, 4.0874628412503400f,
+  4.1699250014423122f, 4.2479275134435852f, 4.3219280948873626f,
+  4.3923174227787607f, 4.4594316186372973f, 4.5235619560570131f,
+  4.5849625007211570f, 4.6438561897747244f, 4.7004397181410926f,
+  4.7548875021634691f, 4.8073549220576037f, 4.8579809951275728f,
+  4.9068905956085187f, 4.9541963103868758f, 5.0000000000000000f,
+  5.0443941193584534f, 5.0874628412503400f, 5.1292830169449664f,
+  5.1699250014423122f, 5.2094533656289501f, 5.2479275134435852f,
+  5.2854022188622487f, 5.3219280948873626f, 5.3575520046180838f,
+  5.3923174227787607f, 5.4262647547020979f, 5.4594316186372973f,
+  5.4918530963296748f, 5.5235619560570131f, 5.5545888516776376f,
+  5.5849625007211570f, 5.6147098441152083f, 5.6438561897747244f,
+  5.6724253419714961f, 5.7004397181410926f, 5.7279204545631996f,
+  5.7548875021634691f, 5.7813597135246599f, 5.8073549220576046f,
+  5.8328900141647422f, 5.8579809951275719f, 5.8826430493618416f,
+  5.9068905956085187f, 5.9307373375628867f, 5.9541963103868758f,
+  5.9772799234999168f, 6.0000000000000000f, 6.0223678130284544f,
+  6.0443941193584534f, 6.0660891904577721f, 6.0874628412503400f,
+  6.1085244567781700f, 6.1292830169449672f, 6.1497471195046822f,
+  6.1699250014423122f, 6.1898245588800176f, 6.2094533656289510f,
+  6.2288186904958804f, 6.2479275134435861f, 6.2667865406949019f,
+  6.2854022188622487f, 6.3037807481771031f, 6.3219280948873617f,
+  6.3398500028846252f, 6.3575520046180847f, 6.3750394313469254f,
+  6.3923174227787598f, 6.4093909361377026f, 6.4262647547020979f,
+  6.4429434958487288f, 6.4594316186372982f, 6.4757334309663976f,
+  6.4918530963296748f, 6.5077946401986964f, 6.5235619560570131f,
+  6.5391588111080319f, 6.5545888516776376f, 6.5698556083309478f,
+  6.5849625007211561f, 6.5999128421871278f, 6.6147098441152092f,
+  6.6293566200796095f, 6.6438561897747253f, 6.6582114827517955f,
+  6.6724253419714952f, 6.6865005271832185f, 6.7004397181410917f,
+  6.7142455176661224f, 6.7279204545631988f, 6.7414669864011465f,
+  6.7548875021634691f, 6.7681843247769260f, 6.7813597135246599f,
+  6.7944158663501062f, 6.8073549220576037f, 6.8201789624151887f,
+  6.8328900141647422f, 6.8454900509443757f, 6.8579809951275719f,
+  6.8703647195834048f, 6.8826430493618416f, 6.8948177633079437f,
+  6.9068905956085187f, 6.9188632372745955f, 6.9307373375628867f,
+  6.9425145053392399f, 6.9541963103868758f, 6.9657842846620879f,
+  6.9772799234999168f, 6.9886846867721664f, 7.0000000000000000f,
+  7.0112272554232540f, 7.0223678130284544f, 7.0334230015374501f,
+  7.0443941193584534f, 7.0552824355011898f, 7.0660891904577721f,
+  7.0768155970508317f, 7.0874628412503400f, 7.0980320829605272f,
+  7.1085244567781700f, 7.1189410727235076f, 7.1292830169449664f,
+  7.1395513523987937f, 7.1497471195046822f, 7.1598713367783891f,
+  7.1699250014423130f, 7.1799090900149345f, 7.1898245588800176f,
+  7.1996723448363644f, 7.2094533656289492f, 7.2191685204621621f,
+  7.2288186904958804f, 7.2384047393250794f, 7.2479275134435861f,
+  7.2573878426926521f, 7.2667865406949019f, 7.2761244052742384f,
+  7.2854022188622487f, 7.2946207488916270f, 7.3037807481771031f,
+  7.3128829552843557f, 7.3219280948873617f, 7.3309168781146177f,
+  7.3398500028846243f, 7.3487281542310781f, 7.3575520046180847f,
+  7.3663222142458151f, 7.3750394313469254f, 7.3837042924740528f,
+  7.3923174227787607f, 7.4008794362821844f, 7.4093909361377026f,
+  7.4178525148858991f, 7.4262647547020979f, 7.4346282276367255f,
+  7.4429434958487288f, 7.4512111118323299f, 7.4594316186372973f,
+  7.4676055500829976f, 7.4757334309663976f, 7.4838157772642564f,
+  7.4918530963296748f, 7.4998458870832057f, 7.5077946401986964f,
+  7.5156998382840436f, 7.5235619560570131f, 7.5313814605163119f,
+  7.5391588111080319f, 7.5468944598876373f, 7.5545888516776376f,
+  7.5622424242210728f, 7.5698556083309478f, 7.5774288280357487f,
+  7.5849625007211561f, 7.5924570372680806f, 7.5999128421871278f,
+  7.6073303137496113f, 7.6147098441152075f, 7.6220518194563764f,
+  7.6293566200796095f, 7.6366246205436488f, 7.6438561897747244f,
+  7.6510516911789290f, 7.6582114827517955f, 7.6653359171851765f,
+  7.6724253419714952f, 7.6794800995054464f, 7.6865005271832185f,
+  7.6934869574993252f, 7.7004397181410926f, 7.7073591320808825f,
+  7.7142455176661224f, 7.7210991887071856f, 7.7279204545631996f,
+  7.7347096202258392f, 7.7414669864011465f, 7.7481928495894596f,
+  7.7548875021634691f, 7.7615512324444795f, 7.7681843247769260f,
+  7.7747870596011737f, 7.7813597135246608f, 7.7879025593914317f,
+  7.7944158663501062f, 7.8008998999203047f, 7.8073549220576037f,
+  7.8137811912170374f, 7.8201789624151887f, 7.8265484872909159f,
+  7.8328900141647422f, 7.8392037880969445f, 7.8454900509443757f,
+  7.8517490414160571f, 7.8579809951275719f, 7.8641861446542798f,
+  7.8703647195834048f, 7.8765169465650002f, 7.8826430493618425f,
+  7.8887432488982601f, 7.8948177633079446f, 7.9008668079807496f,
+  7.9068905956085187f, 7.9128893362299619f, 7.9188632372745955f,
+  7.9248125036057813f, 7.9307373375628867f, 7.9366379390025719f,
+  7.9425145053392399f, 7.9483672315846778f, 7.9541963103868758f,
+  7.9600019320680806f, 7.9657842846620870f, 7.9715435539507720f,
+  7.9772799234999168f, 7.9829935746943104f, 7.9886846867721664f,
+  7.9943534368588578f
+};
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif

data/vendor/brotli/c/enc/fast_log.h

@@ -19,10 +19,8 @@ extern "C" {
 #endif
 
 static BROTLI_INLINE uint32_t Log2FloorNonZero(size_t n) {
-  /* TODO: generalize and move to platform.h */
-#if BROTLI_GNUC_HAS_BUILTIN(__builtin_clz, 3, 4, 0) || \
-    BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
-  return 31u ^ (uint32_t)__builtin_clz((uint32_t)n);
+#if defined(BROTLI_BSR32)
+  return BROTLI_BSR32((uint32_t)n);
 #else
   uint32_t result = 0;
   while (n >>= 1) result++;
@@ -30,110 +28,31 @@ static BROTLI_INLINE uint32_t Log2FloorNonZero(size_t n) {
 #endif
 }
 
+#define BROTLI_LOG2_TABLE_SIZE 256
+
 /* A lookup table for small values of log2(int) to be used in entropy
-   computation.
+   computation. */
+BROTLI_INTERNAL extern const double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE];
 
-   ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]]) */
-static const float kLog2Table[] = {
-  0.0000000000000000f, 0.0000000000000000f, 1.0000000000000000f,
-  1.5849625007211563f, 2.0000000000000000f, 2.3219280948873622f,
-  2.5849625007211561f, 2.8073549220576042f, 3.0000000000000000f,
-  3.1699250014423126f, 3.3219280948873626f, 3.4594316186372978f,
-  3.5849625007211565f, 3.7004397181410922f, 3.8073549220576037f,
-  3.9068905956085187f, 4.0000000000000000f, 4.0874628412503400f,
-  4.1699250014423122f, 4.2479275134435852f, 4.3219280948873626f,
-  4.3923174227787607f, 4.4594316186372973f, 4.5235619560570131f,
-  4.5849625007211570f, 4.6438561897747244f, 4.7004397181410926f,
-  4.7548875021634691f, 4.8073549220576037f, 4.8579809951275728f,
-  4.9068905956085187f, 4.9541963103868758f, 5.0000000000000000f,
-  5.0443941193584534f, 5.0874628412503400f, 5.1292830169449664f,
-  5.1699250014423122f, 5.2094533656289501f, 5.2479275134435852f,
-  5.2854022188622487f, 5.3219280948873626f, 5.3575520046180838f,
-  5.3923174227787607f, 5.4262647547020979f, 5.4594316186372973f,
-  5.4918530963296748f, 5.5235619560570131f, 5.5545888516776376f,
-  5.5849625007211570f, 5.6147098441152083f, 5.6438561897747244f,
-  5.6724253419714961f, 5.7004397181410926f, 5.7279204545631996f,
-  5.7548875021634691f, 5.7813597135246599f, 5.8073549220576046f,
-  5.8328900141647422f, 5.8579809951275719f, 5.8826430493618416f,
-  5.9068905956085187f, 5.9307373375628867f, 5.9541963103868758f,
-  5.9772799234999168f, 6.0000000000000000f, 6.0223678130284544f,
-  6.0443941193584534f, 6.0660891904577721f, 6.0874628412503400f,
-  6.1085244567781700f, 6.1292830169449672f, 6.1497471195046822f,
-  6.1699250014423122f, 6.1898245588800176f, 6.2094533656289510f,
-  6.2288186904958804f, 6.2479275134435861f, 6.2667865406949019f,
-  6.2854022188622487f, 6.3037807481771031f, 6.3219280948873617f,
-  6.3398500028846252f, 6.3575520046180847f, 6.3750394313469254f,
-  6.3923174227787598f, 6.4093909361377026f, 6.4262647547020979f,
-  6.4429434958487288f, 6.4594316186372982f, 6.4757334309663976f,
-  6.4918530963296748f, 6.5077946401986964f, 6.5235619560570131f,
-  6.5391588111080319f, 6.5545888516776376f, 6.5698556083309478f,
-  6.5849625007211561f, 6.5999128421871278f, 6.6147098441152092f,
-  6.6293566200796095f, 6.6438561897747253f, 6.6582114827517955f,
-  6.6724253419714952f, 6.6865005271832185f, 6.7004397181410917f,
-  6.7142455176661224f, 6.7279204545631988f, 6.7414669864011465f,
-  6.7548875021634691f, 6.7681843247769260f, 6.7813597135246599f,
-  6.7944158663501062f, 6.8073549220576037f, 6.8201789624151887f,
-  6.8328900141647422f, 6.8454900509443757f, 6.8579809951275719f,
-  6.8703647195834048f, 6.8826430493618416f, 6.8948177633079437f,
-  6.9068905956085187f, 6.9188632372745955f, 6.9307373375628867f,
-  6.9425145053392399f, 6.9541963103868758f, 6.9657842846620879f,
-  6.9772799234999168f, 6.9886846867721664f, 7.0000000000000000f,
-  7.0112272554232540f, 7.0223678130284544f, 7.0334230015374501f,
-  7.0443941193584534f, 7.0552824355011898f, 7.0660891904577721f,
-  7.0768155970508317f, 7.0874628412503400f, 7.0980320829605272f,
-  7.1085244567781700f, 7.1189410727235076f, 7.1292830169449664f,
-  7.1395513523987937f, 7.1497471195046822f, 7.1598713367783891f,
-  7.1699250014423130f, 7.1799090900149345f, 7.1898245588800176f,
-  7.1996723448363644f, 7.2094533656289492f, 7.2191685204621621f,
-  7.2288186904958804f, 7.2384047393250794f, 7.2479275134435861f,
-  7.2573878426926521f, 7.2667865406949019f, 7.2761244052742384f,
-  7.2854022188622487f, 7.2946207488916270f, 7.3037807481771031f,
-  7.3128829552843557f, 7.3219280948873617f, 7.3309168781146177f,
-  7.3398500028846243f, 7.3487281542310781f, 7.3575520046180847f,
-  7.3663222142458151f, 7.3750394313469254f, 7.3837042924740528f,
-  7.3923174227787607f, 7.4008794362821844f, 7.4093909361377026f,
-  7.4178525148858991f, 7.4262647547020979f, 7.4346282276367255f,
-  7.4429434958487288f, 7.4512111118323299f, 7.4594316186372973f,
-  7.4676055500829976f, 7.4757334309663976f, 7.4838157772642564f,
-  7.4918530963296748f, 7.4998458870832057f, 7.5077946401986964f,
-  7.5156998382840436f, 7.5235619560570131f, 7.5313814605163119f,
-  7.5391588111080319f, 7.5468944598876373f, 7.5545888516776376f,
-  7.5622424242210728f, 7.5698556083309478f, 7.5774288280357487f,
-  7.5849625007211561f, 7.5924570372680806f, 7.5999128421871278f,
-  7.6073303137496113f, 7.6147098441152075f, 7.6220518194563764f,
-  7.6293566200796095f, 7.6366246205436488f, 7.6438561897747244f,
-  7.6510516911789290f, 7.6582114827517955f, 7.6653359171851765f,
-  7.6724253419714952f, 7.6794800995054464f, 7.6865005271832185f,
-  7.6934869574993252f, 7.7004397181410926f, 7.7073591320808825f,
-  7.7142455176661224f, 7.7210991887071856f, 7.7279204545631996f,
-  7.7347096202258392f, 7.7414669864011465f, 7.7481928495894596f,
-  7.7548875021634691f, 7.7615512324444795f, 7.7681843247769260f,
-  7.7747870596011737f, 7.7813597135246608f, 7.7879025593914317f,
-  7.7944158663501062f, 7.8008998999203047f, 7.8073549220576037f,
-  7.8137811912170374f, 7.8201789624151887f, 7.8265484872909159f,
-  7.8328900141647422f, 7.8392037880969445f, 7.8454900509443757f,
-  7.8517490414160571f, 7.8579809951275719f, 7.8641861446542798f,
-  7.8703647195834048f, 7.8765169465650002f, 7.8826430493618425f,
-  7.8887432488982601f, 7.8948177633079446f, 7.9008668079807496f,
-  7.9068905956085187f, 7.9128893362299619f, 7.9188632372745955f,
-  7.9248125036057813f, 7.9307373375628867f, 7.9366379390025719f,
-  7.9425145053392399f, 7.9483672315846778f, 7.9541963103868758f,
-  7.9600019320680806f, 7.9657842846620870f, 7.9715435539507720f,
-  7.9772799234999168f, 7.9829935746943104f, 7.9886846867721664f,
-  7.9943534368588578f
-};
+/* Visual Studio 2012 and Android API levels < 18 do not have the log2()
+ * function defined, so we use log() and a multiplication instead. */
+#if !defined(BROTLI_HAVE_LOG2)
+#if ((defined(_MSC_VER) && _MSC_VER <= 1700) || \
+     (defined(__ANDROID_API__) && __ANDROID_API__ < 18))
+#define BROTLI_HAVE_LOG2 0
+#else
+#define BROTLI_HAVE_LOG2 1
+#endif
+#endif
 
 #define LOG_2_INV 1.4426950408889634
 
 /* Faster logarithm for small integers, with the property of log2(0) == 0. */
 static BROTLI_INLINE double FastLog2(size_t v) {
-  if (v < sizeof(kLog2Table) / sizeof(kLog2Table[0])) {
-    return kLog2Table[v];
+  if (v < BROTLI_LOG2_TABLE_SIZE) {
+    return kBrotliLog2Table[v];
   }
-#if (defined(_MSC_VER) && _MSC_VER <= 1700) || \
-    (defined(__ANDROID_API__) && __ANDROID_API__ < 18)
-  /* Visual Studio 2012 and Android API levels < 18 do not have the log2()
-   * function defined, so we use log() and a multiplication instead. */
+#if !(BROTLI_HAVE_LOG2)
   return log((double)v) * LOG_2_INV;
 #else
   return log2((double)v);

data/vendor/brotli/c/enc/find_match_length.h

@@ -17,8 +17,7 @@ extern "C" {
 #endif
 
 /* Separate implementation for little-endian 64-bit targets, for speed. */
-#if defined(__GNUC__) && defined(_LP64) && defined(BROTLI_LITTLE_ENDIAN)
-
+#if defined(BROTLI_TZCNT64) && BROTLI_64_BITS && BROTLI_LITTLE_ENDIAN
 static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
                                                      const uint8_t* s2,
                                                      size_t limit) {
@@ -32,7 +31,7 @@ static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
     } else {
       uint64_t x = BROTLI_UNALIGNED_LOAD64LE(s2) ^
           BROTLI_UNALIGNED_LOAD64LE(s1 + matched);
-      size_t matching_bits = (size_t)__builtin_ctzll(x);
+      size_t matching_bits = (size_t)BROTLI_TZCNT64(x);
       matched += matching_bits >> 3;
       return matched;
     }

data/vendor/brotli/c/enc/hash.h

@@ -27,34 +27,19 @@
 extern "C" {
 #endif
 
-/* Pointer to hasher data.
- *
- * Excluding initialization and destruction, hasher can be passed as
- * HasherHandle by value.
- *
- * Typically hasher data consists of 3 sections:
- * * HasherCommon structure
- * * private structured hasher data, depending on hasher type
- * * private dynamic hasher data, depending on hasher type and parameters
- *
- * Using "define" instead of "typedef", because on MSVC __restrict does not work
- * on typedef pointer types. */
-#define HasherHandle uint8_t*
-
 typedef struct {
+  /* Dynamically allocated area; first member for quickest access. */
+  void* extra;
+
+  size_t dict_num_lookups;
+  size_t dict_num_matches;
+
   BrotliHasherParams params;
 
   /* False if hasher needs to be "prepared" before use. */
   BROTLI_BOOL is_prepared_;
-
-  size_t dict_num_lookups;
-  size_t dict_num_matches;
 } HasherCommon;
 
-static BROTLI_INLINE HasherCommon* GetHasherCommon(HasherHandle handle) {
-  return (HasherCommon*)handle;
-}
-
 #define score_t size_t
 
 static const uint32_t kCutoffTransformsCount = 10;
@@ -149,17 +134,13 @@ static BROTLI_INLINE score_t BackwardReferencePenaltyUsingLastDistance(
 }
 
 static BROTLI_INLINE BROTLI_BOOL TestStaticDictionaryItem(
-    const BrotliEncoderDictionary* dictionary, size_t item,
+    const BrotliEncoderDictionary* dictionary, size_t len, size_t word_idx,
     const uint8_t* data, size_t max_length, size_t max_backward,
     size_t max_distance, HasherSearchResult* out) {
-  size_t len;
-  size_t word_idx;
   size_t offset;
   size_t matchlen;
   size_t backward;
   score_t score;
-  len = item & 0x1F;
-  word_idx = item >> 5;
   offset = dictionary->words->offsets_by_length[len] + len * word_idx;
   if (len > max_length) {
     return BROTLI_FALSE;
@@ -193,25 +174,24 @@ static BROTLI_INLINE BROTLI_BOOL TestStaticDictionaryItem(
 
 static BROTLI_INLINE void SearchInStaticDictionary(
     const BrotliEncoderDictionary* dictionary,
-    HasherHandle handle, const uint8_t* data, size_t max_length,
+    HasherCommon* common, const uint8_t* data, size_t max_length,
     size_t max_backward, size_t max_distance,
     HasherSearchResult* out, BROTLI_BOOL shallow) {
   size_t key;
   size_t i;
-  HasherCommon* self = GetHasherCommon(handle);
-  if (self->dict_num_matches < (self->dict_num_lookups >> 7)) {
+  if (common->dict_num_matches < (common->dict_num_lookups >> 7)) {
     return;
   }
   key = Hash14(data) << 1;
   for (i = 0; i < (shallow ? 1u : 2u); ++i, ++key) {
-    size_t item = dictionary->hash_table[key];
-    self->dict_num_lookups++;
-    if (item != 0) {
+    common->dict_num_lookups++;
+    if (dictionary->hash_table_lengths[key] != 0) {
       BROTLI_BOOL item_matches = TestStaticDictionaryItem(
-          dictionary, item, data,
+          dictionary, dictionary->hash_table_lengths[key],
+          dictionary->hash_table_words[key], data,
           max_length, max_backward, max_distance, out);
       if (item_matches) {
-        self->dict_num_matches++;
+        common->dict_num_matches++;
       }
     }
   }
@@ -260,37 +240,37 @@ static BROTLI_INLINE size_t BackwardMatchLengthCode(const BackwardMatch* self) {
 /* MAX_NUM_MATCHES == 64 + MAX_TREE_SEARCH_DEPTH */
 #define MAX_NUM_MATCHES_H10 128
 
-/* For BUCKET_SWEEP == 1, enabling the dictionary lookup makes compression
+/* For BUCKET_SWEEP_BITS == 0, enabling the dictionary lookup makes compression
    a little faster (0.5% - 1%) and it compresses 0.15% better on small text
    and HTML inputs. */
 
 #define HASHER() H2
 #define BUCKET_BITS 16
-#define BUCKET_SWEEP 1
+#define BUCKET_SWEEP_BITS 0
 #define HASH_LEN 5
 #define USE_DICTIONARY 1
 #include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
-#undef BUCKET_SWEEP
+#undef BUCKET_SWEEP_BITS
 #undef USE_DICTIONARY
 #undef HASHER
 
 #define HASHER() H3
-#define BUCKET_SWEEP 2
+#define BUCKET_SWEEP_BITS 1
 #define USE_DICTIONARY 0
 #include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
 #undef USE_DICTIONARY
-#undef BUCKET_SWEEP
+#undef BUCKET_SWEEP_BITS
 #undef BUCKET_BITS
 #undef HASHER
 
 #define HASHER() H4
 #define BUCKET_BITS 17
-#define BUCKET_SWEEP 4
+#define BUCKET_SWEEP_BITS 2
 #define USE_DICTIONARY 1
 #include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
 #undef USE_DICTIONARY
 #undef HASH_LEN
-#undef BUCKET_SWEEP
+#undef BUCKET_SWEEP_BITS
 #undef BUCKET_BITS
 #undef HASHER
 
@@ -334,13 +314,13 @@ static BROTLI_INLINE size_t BackwardMatchLengthCode(const BackwardMatch* self) {
 
 #define HASHER() H54
 #define BUCKET_BITS 20
-#define BUCKET_SWEEP 4
+#define BUCKET_SWEEP_BITS 2
 #define HASH_LEN 7
 #define USE_DICTIONARY 0
 #include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
 #undef USE_DICTIONARY
 #undef HASH_LEN
-#undef BUCKET_SWEEP
+#undef BUCKET_SWEEP_BITS
 #undef BUCKET_BITS
 #undef HASHER
 
@@ -393,97 +373,107 @@ static BROTLI_INLINE size_t BackwardMatchLengthCode(const BackwardMatch* self) {
 #undef CAT
 #undef EXPAND_CAT
 
-#define FOR_GENERIC_HASHERS(H) H(2) H(3) H(4) H(5) H(6) H(40) H(41) H(42) H(54)\
-                               H(35) H(55) H(65)
+#define FOR_SIMPLE_HASHERS(H) H(2) H(3) H(4) H(5) H(6) H(40) H(41) H(42) H(54)
+#define FOR_COMPOSITE_HASHERS(H) H(35) H(55) H(65)
+#define FOR_GENERIC_HASHERS(H) FOR_SIMPLE_HASHERS(H) FOR_COMPOSITE_HASHERS(H)
 #define FOR_ALL_HASHERS(H) FOR_GENERIC_HASHERS(H) H(10)
 
-static BROTLI_INLINE void DestroyHasher(
-    MemoryManager* m, HasherHandle* handle) {
-  if (*handle == NULL) return;
-  BROTLI_FREE(m, *handle);
+typedef struct {
+  HasherCommon common;
+
+  union {
+#define MEMBER_(N) \
+    H ## N _H ## N;
+    FOR_ALL_HASHERS(MEMBER_)
+#undef MEMBER_
+  } privat;
+} Hasher;
+
+/* MUST be invoked before any other method. */
+static BROTLI_INLINE void HasherInit(Hasher* hasher) {
+  hasher->common.extra = NULL;
 }
 
-static BROTLI_INLINE void HasherReset(HasherHandle handle) {
-  if (handle == NULL) return;
-  GetHasherCommon(handle)->is_prepared_ = BROTLI_FALSE;
+static BROTLI_INLINE void DestroyHasher(MemoryManager* m, Hasher* hasher) {
+  if (hasher->common.extra == NULL) return;
+  BROTLI_FREE(m, hasher->common.extra);
+}
+
+static BROTLI_INLINE void HasherReset(Hasher* hasher) {
+  hasher->common.is_prepared_ = BROTLI_FALSE;
 }
 
 static BROTLI_INLINE size_t HasherSize(const BrotliEncoderParams* params,
     BROTLI_BOOL one_shot, const size_t input_size) {
-  size_t result = sizeof(HasherCommon);
   switch (params->hasher.type) {
-#define SIZE_(N)                                                         \
-    case N:                                                              \
-      result += HashMemAllocInBytesH ## N(params, one_shot, input_size); \
-      break;
+#define SIZE_(N)                                                      \
+    case N:                                                           \
+      return HashMemAllocInBytesH ## N(params, one_shot, input_size);
     FOR_ALL_HASHERS(SIZE_)
 #undef SIZE_
     default:
       break;
   }
-  return result;
+  return 0;  /* Default case. */
 }
 
-static BROTLI_INLINE void HasherSetup(MemoryManager* m, HasherHandle* handle,
+static BROTLI_INLINE void HasherSetup(MemoryManager* m, Hasher* hasher,
     BrotliEncoderParams* params, const uint8_t* data, size_t position,
     size_t input_size, BROTLI_BOOL is_last) {
-  HasherHandle self = NULL;
-  HasherCommon* common = NULL;
   BROTLI_BOOL one_shot = (position == 0 && is_last);
-  if (*handle == NULL) {
+  if (hasher->common.extra == NULL) {
     size_t alloc_size;
     ChooseHasher(params, &params->hasher);
     alloc_size = HasherSize(params, one_shot, input_size);
-    self = BROTLI_ALLOC(m, uint8_t, alloc_size);
-    if (BROTLI_IS_OOM(m)) return;
-    *handle = self;
-    common = GetHasherCommon(self);
-    common->params = params->hasher;
-    switch (common->params.type) {
-#define INITIALIZE_(N)                     \
-      case N:                              \
-        InitializeH ## N(*handle, params); \
+    hasher->common.extra = BROTLI_ALLOC(m, uint8_t, alloc_size);
+    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(hasher->common.extra)) return;
+    hasher->common.params = params->hasher;
+    switch (hasher->common.params.type) {
+#define INITIALIZE_(N)                        \
+      case N:                                 \
+        InitializeH ## N(&hasher->common,     \
+            &hasher->privat._H ## N, params); \
         break;
       FOR_ALL_HASHERS(INITIALIZE_);
 #undef INITIALIZE_
       default:
         break;
     }
-    HasherReset(*handle);
+    HasherReset(hasher);
   }
 
-  self = *handle;
-  common = GetHasherCommon(self);
-  if (!common->is_prepared_) {
-    switch (common->params.type) {
-#define PREPARE_(N)                                      \
-      case N:                                            \
-        PrepareH ## N(self, one_shot, input_size, data); \
+  if (!hasher->common.is_prepared_) {
+    switch (hasher->common.params.type) {
+#define PREPARE_(N)                      \
+      case N:                            \
+        PrepareH ## N(                   \
+            &hasher->privat._H ## N,     \
+            one_shot, input_size, data); \
         break;
       FOR_ALL_HASHERS(PREPARE_)
 #undef PREPARE_
       default: break;
     }
     if (position == 0) {
-        common->dict_num_lookups = 0;
-        common->dict_num_matches = 0;
+      hasher->common.dict_num_lookups = 0;
+      hasher->common.dict_num_matches = 0;
     }
-    common->is_prepared_ = BROTLI_TRUE;
+    hasher->common.is_prepared_ = BROTLI_TRUE;
   }
 }
 
 static BROTLI_INLINE void InitOrStitchToPreviousBlock(
-    MemoryManager* m, HasherHandle* handle, const uint8_t* data, size_t mask,
+    MemoryManager* m, Hasher* hasher, const uint8_t* data, size_t mask,
     BrotliEncoderParams* params, size_t position, size_t input_size,
     BROTLI_BOOL is_last) {
-  HasherHandle self;
-  HasherSetup(m, handle, params, data, position, input_size, is_last);
+  HasherSetup(m, hasher, params, data, position, input_size, is_last);
   if (BROTLI_IS_OOM(m)) return;
-  self = *handle;
-  switch (GetHasherCommon(self)->params.type) {
-#define INIT_(N)                                                           \
-    case N:                                                                \
-      StitchToPreviousBlockH ## N(self, input_size, position, data, mask); \
+  switch (hasher->common.params.type) {
+#define INIT_(N)                             \
+    case N:                                  \
+      StitchToPreviousBlockH ## N(           \
+          &hasher->privat._H ## N,           \
+          input_size, position, data, mask); \
     break;
     FOR_ALL_HASHERS(INIT_)
 #undef INIT_