@@ -1,5 +1,5 @@

 /* This file has been backported by dev-tools/lz4-rebaser.sh

- * from upstream lz4 commit 7bb64ff2b69a9f8367de (v1.7.5)

+ * from upstream lz4 commit fdf2ef5809ca875c4545 (v1.9.2)

  */

 #ifdef HAVE_CONFIG_H

 #include "config.h"

@@ -10,7 +10,7 @@

 #ifdef NEED_COMPAT_LZ4

 /*

    LZ4 - Fast LZ compression algorithm

-   Copyright (C) 2011-2016, Yann Collet.

+   Copyright (C) 2011-present, Yann Collet.

    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

@@ -42,17 +42,16 @@

     - LZ4 source repository : https://github.com/lz4/lz4

 */

-

 /*-************************************

 *  Tuning parameters

 **************************************/

 /*

- * HEAPMODE :

+ * LZ4_HEAPMODE :

  * Select how default compression functions will allocate memory for their hash table,

  * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).

  */

-#ifndef HEAPMODE

-#  define HEAPMODE 0

+#ifndef LZ4_HEAPMODE

+#  define LZ4_HEAPMODE 0

 #endif

 /*

@@ -73,16 +72,17 @@

  * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).

  *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.

  * Method 2 : direct access. This method is portable but violate C standard.

- *            It can generate buggy code on targets which generate assembly depending on alignment.

+ *            It can generate buggy code on targets which assembly generation depends on alignment.

  *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)

  * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.

  * Prefer these methods in priority order (0 > 1 > 2)

  */

-#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */

-#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )

+#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */

+#  if defined(__GNUC__) && \

+  ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \

+  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )

 #    define LZ4_FORCE_MEMORY_ACCESS 2

-#  elif defined(__INTEL_COMPILER) || \

-  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))

+#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__)

 #    define LZ4_FORCE_MEMORY_ACCESS 1

 #  endif

 #endif

@@ -91,14 +91,32 @@

  * LZ4_FORCE_SW_BITCOUNT

  * Define this parameter if your target system or compiler does not support hardware bit count

  */

-#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for Windows CE does not support Hardware bit count */

+#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for WinCE doesn't support Hardware bit count */

 #  define LZ4_FORCE_SW_BITCOUNT

 #endif

+

 /*-************************************

 *  Dependency

 **************************************/

+/*

+ * LZ4_SRC_INCLUDED:

+ * Amalgamation flag, whether lz4.c is included

+ */

+#ifndef LZ4_SRC_INCLUDED

+#  define LZ4_SRC_INCLUDED 1

+#endif

+

+#ifndef LZ4_STATIC_LINKING_ONLY

+#define LZ4_STATIC_LINKING_ONLY

+#endif

+

+#ifndef LZ4_DISABLE_DEPRECATE_WARNINGS

+#define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */

+#endif

+

+#define LZ4_STATIC_LINKING_ONLY  /* LZ4_DISTANCE_MAX */

 #include "compat-lz4.h"

 /* see also "memory routines" below */

@@ -107,42 +125,130 @@

 *  Compiler Options

 **************************************/

 #ifdef _MSC_VER    /* Visual Studio */

-#  define FORCE_INLINE static __forceinline

 #  include <intrin.h>

 #  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */

 #  pragma warning(disable : 4293)        /* disable: C4293: too large shift (32-bits) */

-#else

-#  if defined(__GNUC__) || defined(__clang__)

-#    define FORCE_INLINE static inline __attribute__((always_inline))

-#  elif defined(__cplusplus) || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)

-#    define FORCE_INLINE static inline

-#  else

-#    define FORCE_INLINE static

-#  endif

 #endif  /* _MSC_VER */

+#ifndef LZ4_FORCE_INLINE

+#  ifdef _MSC_VER    /* Visual Studio */

+#    define LZ4_FORCE_INLINE static __forceinline

+#  else

+#    if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */

+#      ifdef __GNUC__

+#        define LZ4_FORCE_INLINE static inline __attribute__((always_inline))

+#      else

+#        define LZ4_FORCE_INLINE static inline

+#      endif

+#    else

+#      define LZ4_FORCE_INLINE static

+#    endif /* __STDC_VERSION__ */

+#  endif  /* _MSC_VER */

+#endif /* LZ4_FORCE_INLINE */

+

+/* LZ4_FORCE_O2_GCC_PPC64LE and LZ4_FORCE_O2_INLINE_GCC_PPC64LE

+ * gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy8,

+ * together with a simple 8-byte copy loop as a fall-back path.

+ * However, this optimization hurts the decompression speed by >30%,

+ * because the execution does not go to the optimized loop

+ * for typical compressible data, and all of the preamble checks

+ * before going to the fall-back path become useless overhead.

+ * This optimization happens only with the -O3 flag, and -O2 generates

+ * a simple 8-byte copy loop.

+ * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy8

+ * functions are annotated with __attribute__((optimize("O2"))),

+ * and also LZ4_wildCopy8 is forcibly inlined, so that the O2 attribute

+ * of LZ4_wildCopy8 does not affect the compression speed.

+ */

+#if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__) && !defined(__clang__)

+#  define LZ4_FORCE_O2_GCC_PPC64LE __attribute__((optimize("O2")))

+#  define LZ4_FORCE_O2_INLINE_GCC_PPC64LE __attribute__((optimize("O2"))) LZ4_FORCE_INLINE

+#else

+#  define LZ4_FORCE_O2_GCC_PPC64LE

+#  define LZ4_FORCE_O2_INLINE_GCC_PPC64LE static

+#endif

+

 #if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)

 #  define expect(expr,value)    (__builtin_expect ((expr),(value)) )

 #else

 #  define expect(expr,value)    (expr)

 #endif

+#ifndef likely

 #define likely(expr)     expect((expr) != 0, 1)

+#endif

+#ifndef unlikely

 #define unlikely(expr)   expect((expr) != 0, 0)

+#endif

 /*-************************************

 *  Memory routines

 **************************************/

 #include <stdlib.h>   /* malloc, calloc, free */

-#define ALLOCATOR(n,s) calloc(n,s)

-#define FREEMEM        free

+#define ALLOC(s)          malloc(s)

+#define ALLOC_AND_ZERO(s) calloc(1,s)

+#define FREEMEM(p)        free(p)

 #include <string.h>   /* memset, memcpy */

-#define MEM_INIT       memset

+#define MEM_INIT(p,v,s)   memset((p),(v),(s))

 /*-************************************

-*  Basic Types

+*  Common Constants

+**************************************/

+#define MINMATCH 4

+

+#define WILDCOPYLENGTH 8

+#define LASTLITERALS   5   /* see ../doc/lz4_Block_format.md#parsing-restrictions */

+#define MFLIMIT       12   /* see ../doc/lz4_Block_format.md#parsing-restrictions */

+#define MATCH_SAFEGUARD_DISTANCE  ((2*WILDCOPYLENGTH) - MINMATCH)   /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */

+#define FASTLOOP_SAFE_DISTANCE 64

+static const int LZ4_minLength = (MFLIMIT+1);

+

+#define KB *(1 <<10)

+#define MB *(1 <<20)

+#define GB *(1U<<30)

+

+#define LZ4_DISTANCE_ABSOLUTE_MAX 65535

+#if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX)   /* max supported by LZ4 format */

+#  error "LZ4_DISTANCE_MAX is too big : must be <= 65535"

+#endif

+

+#define ML_BITS  4

+#define ML_MASK  ((1U<<ML_BITS)-1)

+#define RUN_BITS (8-ML_BITS)

+#define RUN_MASK ((1U<<RUN_BITS)-1)

+

+

+/*-************************************

+*  Error detection

+**************************************/

+#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)

+#  include <assert.h>

+#else

+#  ifndef assert

+#    define assert(condition) ((void)0)

+#  endif

+#endif

+

+#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use after variable declarations */

+

+#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)

+#  include <stdio.h>

+static int g_debuglog_enable = 1;

+#  define DEBUGLOG(l, ...) {                                  \

+                if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \

+                    fprintf(stderr, __FILE__ ": ");           \

+                    fprintf(stderr, __VA_ARGS__);             \

+                    fprintf(stderr, " \n");                   \

+            }   }

+#else

+#  define DEBUGLOG(l, ...)      {}    /* disabled */

+#endif

+

+

+/*-************************************

+*  Types

 **************************************/

 #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)

 # include <stdint.h>

@@ -167,6 +273,13 @@

   typedef size_t reg_t;   /* 32-bits in x32 mode */

 #endif

+typedef enum {

+    notLimited = 0,

+    limitedOutput = 1,

+    fillOutput = 2

+} limitedOutput_directive;

+

+

 /*-************************************

 *  Reading and writing into memory

 **************************************/

@@ -200,7 +313,7 @@ static reg_t LZ4_read_ARCH(const void* ptr) { return ((const unalign*)ptr)->uArc

 static void LZ4_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }

 static void LZ4_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }

-#else  /* safe and portable access through memcpy() */

+#else  /* safe and portable access using memcpy() */

 static U16 LZ4_read16(const void* memPtr)

 {

@@ -251,55 +364,113 @@ static void LZ4_writeLE16(void* memPtr, U16 value)

     }

 }

-static void LZ4_copy8(void* dst, const void* src)

-{

-    memcpy(dst,src,8);

-}

-

 /* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */

-static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd)

+LZ4_FORCE_O2_INLINE_GCC_PPC64LE

+void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)

 {

     BYTE* d = (BYTE*)dstPtr;

     const BYTE* s = (const BYTE*)srcPtr;

     BYTE* const e = (BYTE*)dstEnd;

-    do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);

+    do { memcpy(d,s,8); d+=8; s+=8; } while (d<e);

 }

+static const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};

+static const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};

-/*-************************************

-*  Common Constants

-**************************************/

-#define MINMATCH 4

-#define WILDCOPYLENGTH 8

-#define LASTLITERALS 5

-#define MFLIMIT (WILDCOPYLENGTH+MINMATCH)

-static const int LZ4_minLength = (MFLIMIT+1);

+#ifndef LZ4_FAST_DEC_LOOP

+#  if defined(__i386__) || defined(__x86_64__)

+#    define LZ4_FAST_DEC_LOOP 1

+#  elif defined(__aarch64__) && !defined(__clang__)

+     /* On aarch64, we disable this optimization for clang because on certain

+      * mobile chipsets and clang, it reduces performance. For more information

+      * refer to https://github.com/lz4/lz4/pull/707. */

+#    define LZ4_FAST_DEC_LOOP 1

+#  else

+#    define LZ4_FAST_DEC_LOOP 0

+#  endif

+#endif

-#define KB *(1 <<10)

-#define MB *(1 <<20)

-#define GB *(1U<<30)

+#if LZ4_FAST_DEC_LOOP

+

+LZ4_FORCE_O2_INLINE_GCC_PPC64LE void

+LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)

+{

+    if (offset < 8) {

+        dstPtr[0] = srcPtr[0];

+        dstPtr[1] = srcPtr[1];

+        dstPtr[2] = srcPtr[2];

+        dstPtr[3] = srcPtr[3];

+        srcPtr += inc32table[offset];

+        memcpy(dstPtr+4, srcPtr, 4);

+        srcPtr -= dec64table[offset];

+        dstPtr += 8;

+    } else {

+        memcpy(dstPtr, srcPtr, 8);

+        dstPtr += 8;

+        srcPtr += 8;

+    }

-#define MAXD_LOG 16

-#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)

+    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);

+}

-#define ML_BITS  4

-#define ML_MASK  ((1U<<ML_BITS)-1)

-#define RUN_BITS (8-ML_BITS)

-#define RUN_MASK ((1U<<RUN_BITS)-1)

+/* customized variant of memcpy, which can overwrite up to 32 bytes beyond dstEnd

+ * this version copies two times 16 bytes (instead of one time 32 bytes)

+ * because it must be compatible with offsets >= 16. */

+LZ4_FORCE_O2_INLINE_GCC_PPC64LE void

+LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)

+{

+    BYTE* d = (BYTE*)dstPtr;

+    const BYTE* s = (const BYTE*)srcPtr;

+    BYTE* const e = (BYTE*)dstEnd;

+

+    do { memcpy(d,s,16); memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);

+}

+/* LZ4_memcpy_using_offset()  presumes :

+ * - dstEnd >= dstPtr + MINMATCH

+ * - there is at least 8 bytes available to write after dstEnd */

+LZ4_FORCE_O2_INLINE_GCC_PPC64LE void

+LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)

+{

+    BYTE v[8];

-/*-************************************

-*  Common Utils

-**************************************/

-#define LZ4_STATIC_ASSERT(c)    { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */

+    assert(dstEnd >= dstPtr + MINMATCH);

+    LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */

+

+    switch(offset) {

+    case 1:

+        memset(v, *srcPtr, 8);

+        break;

+    case 2:

+        memcpy(v, srcPtr, 2);

+        memcpy(&v[2], srcPtr, 2);

+        memcpy(&v[4], &v[0], 4);

+        break;

+    case 4:

+        memcpy(v, srcPtr, 4);

+        memcpy(&v[4], srcPtr, 4);

+        break;

+    default:

+        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);

+        return;

+    }

+

+    memcpy(dstPtr, v, 8);

+    dstPtr += 8;

+    while (dstPtr < dstEnd) {

+        memcpy(dstPtr, v, 8);

+        dstPtr += 8;

+    }

+}

+#endif

 /*-************************************

 *  Common functions

 **************************************/

-static unsigned LZ4_NbCommonBytes (register reg_t val)

+static unsigned LZ4_NbCommonBytes (reg_t val)

 {

     if (LZ4_isLittleEndian()) {

         if (sizeof(val)==8) {

@@ -308,9 +479,16 @@ static unsigned LZ4_NbCommonBytes (register reg_t val)

             _BitScanForward64( &r, (U64)val );

             return (int)(r>>3);

 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)

-            return (__builtin_ctzll((U64)val) >> 3);

+            return (unsigned)__builtin_ctzll((U64)val) >> 3;

 #       else

-            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };

+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2,

+                                                     0, 3, 1, 3, 1, 4, 2, 7,

+                                                     0, 2, 3, 6, 1, 5, 3, 5,

+                                                     1, 3, 4, 4, 2, 5, 6, 7,

+                                                     7, 0, 1, 2, 3, 3, 4, 6,

+                                                     2, 6, 5, 5, 3, 4, 5, 6,

+                                                     7, 1, 2, 4, 6, 4, 4, 5,

+                                                     7, 2, 6, 5, 7, 6, 7, 7 };

             return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];

 #       endif

         } else /* 32 bits */ {

@@ -319,23 +497,29 @@ static unsigned LZ4_NbCommonBytes (register reg_t val)

             _BitScanForward( &r, (U32)val );

             return (int)(r>>3);

 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)

-            return (__builtin_ctz((U32)val) >> 3);

+            return (unsigned)__builtin_ctz((U32)val) >> 3;

 #       else

-            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };

+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0,

+                                                     3, 2, 2, 1, 3, 2, 0, 1,

+                                                     3, 3, 1, 2, 2, 2, 2, 0,

+                                                     3, 1, 2, 0, 1, 0, 1, 1 };

             return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];

 #       endif

         }

     } else   /* Big Endian CPU */ {

-        if (sizeof(val)==8) {

+        if (sizeof(val)==8) {   /* 64-bits */

 #       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)

             unsigned long r = 0;

             _BitScanReverse64( &r, val );

             return (unsigned)(r>>3);

 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)

-            return (__builtin_clzll((U64)val) >> 3);

+            return (unsigned)__builtin_clzll((U64)val) >> 3;

 #       else

+            static const U32 by32 = sizeof(val)*4;  /* 32 on 64 bits (goal), 16 on 32 bits.

+                Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.

+                Note that this code path is never triggered in 32-bits mode. */

             unsigned r;

-            if (!(val>>32)) { r=4; } else { r=0; val>>=32; }

+            if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }

             if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }

             r += (!val);

             return r;

@@ -346,7 +530,7 @@ static unsigned LZ4_NbCommonBytes (register reg_t val)

             _BitScanReverse( &r, (unsigned long)val );

             return (unsigned)(r>>3);

 #       elif (defined(__clang__) || (defined(__GNUC__) && (__GNUC__>=3))) && !defined(LZ4_FORCE_SW_BITCOUNT)

-            return (__builtin_clz((U32)val) >> 3);

+            return (unsigned)__builtin_clz((U32)val) >> 3;

 #       else

             unsigned r;

             if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }

@@ -358,11 +542,20 @@ static unsigned LZ4_NbCommonBytes (register reg_t val)

 }

 #define STEPSIZE sizeof(reg_t)

-static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)

+LZ4_FORCE_INLINE

+unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)

 {

     const BYTE* const pStart = pIn;

-    while (likely(pIn<pInLimit-(STEPSIZE-1))) {

+    if (likely(pIn < pInLimit-(STEPSIZE-1))) {

+        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);

+        if (!diff) {

+            pIn+=STEPSIZE; pMatch+=STEPSIZE;

+        } else {

+            return LZ4_NbCommonBytes(diff);

+    }   }

+

+    while (likely(pIn < pInLimit-(STEPSIZE-1))) {

         reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);

         if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }

         pIn += LZ4_NbCommonBytes(diff);

@@ -387,15 +580,34 @@ static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression ru

 /*-************************************

 *  Local Structures and types

 **************************************/

-typedef enum { notLimited = 0, limitedOutput = 1 } limitedOutput_directive;

-typedef enum { byPtr, byU32, byU16 } tableType_t;

-

-typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive;

+typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t;

+

+/**

+ * This enum distinguishes several different modes of accessing previous

+ * content in the stream.

+ *

+ * - noDict        : There is no preceding content.

+ * - withPrefix64k : Table entries up to ctx->dictSize before the current blob

+ *                   blob being compressed are valid and refer to the preceding

+ *                   content (of length ctx->dictSize), which is available

+ *                   contiguously preceding in memory the content currently

+ *                   being compressed.

+ * - usingExtDict  : Like withPrefix64k, but the preceding content is somewhere

+ *                   else in memory, starting at ctx->dictionary with length

+ *                   ctx->dictSize.

+ * - usingDictCtx  : Like usingExtDict, but everything concerning the preceding

+ *                   content is in a separate context, pointed to by

+ *                   ctx->dictCtx. ctx->dictionary, ctx->dictSize, and table

+ *                   entries in the current context that refer to positions

+ *                   preceding the beginning of the current compression are

+ *                   ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx

+ *                   ->dictSize describe the location and size of the preceding

+ *                   content, and matches are found by looking in the ctx

+ *                   ->dictCtx->hashTable.

+ */

+typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;

 typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;

-typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;

-typedef enum { full = 0, partial = 1 } earlyEnd_directive;

-

 /*-************************************

 *  Local Utils

@@ -406,6 +618,23 @@ int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }

 int LZ4_sizeofState() { return LZ4_STREAMSIZE; }

+/*-************************************

+*  Internal Definitions used in Tests

+**************************************/

+#if defined (__cplusplus)

+extern "C" {

+#endif

+

+int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize);

+

+int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,

+                                     int compressedSize, int maxOutputSize,

+                                     const void* dictStart, size_t dictSize);

+

+#if defined (__cplusplus)

+}

+#endif

+

 /*-******************************

 *  Compression functions

 ********************************/

@@ -419,102 +648,225 @@ static U32 LZ4_hash4(U32 sequence, tableType_t const tableType)

 static U32 LZ4_hash5(U64 sequence, tableType_t const tableType)

 {

-    static const U64 prime5bytes = 889523592379ULL;

-    static const U64 prime8bytes = 11400714785074694791ULL;

     const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;

-    if (LZ4_isLittleEndian())

+    if (LZ4_isLittleEndian()) {

+        const U64 prime5bytes = 889523592379ULL;

         return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));

-    else

+    } else {

+        const U64 prime8bytes = 11400714785074694791ULL;

         return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));

+    }

 }

-FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)

+LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)

 {

     if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);

     return LZ4_hash4(LZ4_read32(p), tableType);

 }

-static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t const tableType, const BYTE* srcBase)

+static void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)

 {

     switch (tableType)

     {

+    default: /* fallthrough */

+    case clearedTable: { /* illegal! */ assert(0); return; }

+    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }

+    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }

+    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }

+    }

+}

+

+static void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)

+{

+    switch (tableType)

+    {

+    default: /* fallthrough */

+    case clearedTable: /* fallthrough */

+    case byPtr: { /* illegal! */ assert(0); return; }

+    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }

+    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }

+    }

+}

+

+static void LZ4_putPositionOnHash(const BYTE* p, U32 h,

+                                  void* tableBase, tableType_t const tableType,

+                            const BYTE* srcBase)

+{

+    switch (tableType)

+    {

+    case clearedTable: { /* illegal! */ assert(0); return; }

     case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }

     case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }

     case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }

     }

 }

-FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)

+LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)

 {

     U32 const h = LZ4_hashPosition(p, tableType);

     LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);

 }

-static const BYTE* LZ4_getPositionOnHash(U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase)

+/* LZ4_getIndexOnHash() :

+ * Index of match position registered in hash table.

+ * hash position must be calculated by using base+index, or dictBase+index.

+ * Assumption 1 : only valid if tableType == byU32 or byU16.

+ * Assumption 2 : h is presumed valid (within limits of hash table)

+ */

+static U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)

+{

+    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);

+    if (tableType == byU32) {

+        const U32* const hashTable = (const U32*) tableBase;

+        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));

+        return hashTable[h];

+    }

+    if (tableType == byU16) {

+        const U16* const hashTable = (const U16*) tableBase;

+        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));

+        return hashTable[h];

+    }

+    assert(0); return 0;  /* forbidden case */

+}

+

+static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType, const BYTE* srcBase)

 {

-    if (tableType == byPtr) { const BYTE** hashTable = (const BYTE**) tableBase; return hashTable[h]; }

-    if (tableType == byU32) { const U32* const hashTable = (U32*) tableBase; return hashTable[h] + srcBase; }

-    { const U16* const hashTable = (U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */

+    if (tableType == byPtr) { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }

+    if (tableType == byU32) { const U32* const hashTable = (const U32*) tableBase; return hashTable[h] + srcBase; }

+    { const U16* const hashTable = (const U16*) tableBase; return hashTable[h] + srcBase; }   /* default, to ensure a return */

 }

-FORCE_INLINE const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)

+LZ4_FORCE_INLINE const BYTE*

+LZ4_getPosition(const BYTE* p,

+                const void* tableBase, tableType_t tableType,

+                const BYTE* srcBase)

 {

     U32 const h = LZ4_hashPosition(p, tableType);

     return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);

 }

+LZ4_FORCE_INLINE void

+LZ4_prepareTable(LZ4_stream_t_internal* const cctx,

+           const int inputSize,

+           const tableType_t tableType) {

+    /* If compression failed during the previous step, then the context

+     * is marked as dirty, therefore, it has to be fully reset.

+     */

+    if (cctx->dirty) {

+        DEBUGLOG(5, "LZ4_prepareTable: Full reset for %p", cctx);

+        MEM_INIT(cctx, 0, sizeof(LZ4_stream_t_internal));

+        return;

+    }

+

+    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is

+     * therefore safe to use no matter what mode we're in. Otherwise, we figure

+     * out if it's safe to leave as is or whether it needs to be reset.

+     */

+    if (cctx->tableType != clearedTable) {

+        assert(inputSize >= 0);

+        if (cctx->tableType != tableType

+          || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)

+          || ((tableType == byU32) && cctx->currentOffset > 1 GB)

+          || tableType == byPtr

+          || inputSize >= 4 KB)

+        {

+            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);

+            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);

+            cctx->currentOffset = 0;

+            cctx->tableType = clearedTable;

+        } else {

+            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");

+        }

+    }

+

+    /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back, is faster

+     * than compressing without a gap. However, compressing with

+     * currentOffset == 0 is faster still, so we preserve that case.

+     */

+    if (cctx->currentOffset != 0 && tableType == byU32) {

+        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");

+        cctx->currentOffset += 64 KB;

+    }

+

+    /* Finally, clear history */

+    cctx->dictCtx = NULL;

+    cctx->dictionary = NULL;

+    cctx->dictSize = 0;

+}

 /** LZ4_compress_generic() :

     inlined, to ensure branches are decided at compilation time */

-FORCE_INLINE int LZ4_compress_generic(

+LZ4_FORCE_INLINE int LZ4_compress_generic(

                  LZ4_stream_t_internal* const cctx,

                  const char* const source,

                  char* const dest,

                  const int inputSize,

+                 int *inputConsumed, /* only written when outputDirective == fillOutput */

                  const int maxOutputSize,

-                 const limitedOutput_directive outputLimited,

+                 const limitedOutput_directive outputDirective,

                  const tableType_t tableType,

-                 const dict_directive dict,

+                 const dict_directive dictDirective,

                  const dictIssue_directive dictIssue,

-                 const U32 acceleration)

+                 const int acceleration)

 {

+    int result;

     const BYTE* ip = (const BYTE*) source;

-    const BYTE* base;

+

+    U32 const startIndex = cctx->currentOffset;

+    const BYTE* base = (const BYTE*) source - startIndex;

     const BYTE* lowLimit;

-    const BYTE* const lowRefLimit = ip - cctx->dictSize;

-    const BYTE* const dictionary = cctx->dictionary;

-    const BYTE* const dictEnd = dictionary + cctx->dictSize;

-    const ptrdiff_t dictDelta = dictEnd - (const BYTE*)source;

+

+    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;

+    const BYTE* const dictionary =

+        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;

+    const U32 dictSize =

+        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;

+    const U32 dictDelta = (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with index in current context */

+

+    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);

+    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */

+    const BYTE* const dictEnd = dictionary + dictSize;

     const BYTE* anchor = (const BYTE*) source;

     const BYTE* const iend = ip + inputSize;

-    const BYTE* const mflimit = iend - MFLIMIT;

+    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;

     const BYTE* const matchlimit = iend - LASTLITERALS;

+    /* the dictCtx currentOffset is indexed on the start of the dictionary,

+     * while a dictionary in the current context precedes the currentOffset */

+    const BYTE* dictBase = (dictDirective == usingDictCtx) ?

+                            dictionary + dictSize - dictCtx->currentOffset :

+                            dictionary + dictSize - startIndex;

+

     BYTE* op = (BYTE*) dest;

     BYTE* const olimit = op + maxOutputSize;

+    U32 offset = 0;

     U32 forwardH;

-    /* Init conditions */

-    if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0;   /* Unsupported inputSize, too large (or negative) */

-    switch(dict)

-    {

-    case noDict:

-    default:

-        base = (const BYTE*)source;

-        lowLimit = (const BYTE*)source;

-        break;

-    case withPrefix64k:

-        base = (const BYTE*)source - cctx->currentOffset;

-        lowLimit = (const BYTE*)source - cctx->dictSize;

-        break;

-    case usingExtDict:

-        base = (const BYTE*)source - cctx->currentOffset;

-        lowLimit = (const BYTE*)source;

-        break;

+    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, tableType=%u", inputSize, tableType);

+    /* If init conditions are not met, we don't have to mark stream

+     * as having dirty context, since no action was taken yet */

+    if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */

+    if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; }           /* Unsupported inputSize, too large (or negative) */

+    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) { return 0; }  /* Size too large (not within 64K limit) */

+    if (tableType==byPtr) assert(dictDirective==noDict);      /* only supported use case with byPtr */

+    assert(acceleration >= 1);

+

+    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);

+

+    /* Update context state */

+    if (dictDirective == usingDictCtx) {

+        /* Subsequent linked blocks can't use the dictionary. */

+        /* Instead, they use the block we just compressed. */

+        cctx->dictCtx = NULL;

+        cctx->dictSize = (U32)inputSize;

+    } else {

+        cctx->dictSize += (U32)inputSize;

     }

-    if ((tableType == byU16) && (inputSize>=LZ4_64Klimit)) return 0;   /* Size too large (not within 64K limit) */

-    if (inputSize<LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */

+    cctx->currentOffset += (U32)inputSize;

+    cctx->tableType = (U16)tableType;

+

+    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */

     /* First Byte */

     LZ4_putPosition(ip, cctx->hashTable, tableType, base);

@@ -522,50 +874,112 @@ FORCE_INLINE int LZ4_compress_generic(

     /* Main Loop */

     for ( ; ; ) {

-        ptrdiff_t refDelta = 0;

         const BYTE* match;

         BYTE* token;

+        const BYTE* filledIp;

         /* Find a match */

-        {   const BYTE* forwardIp = ip;

-            unsigned step = 1;

-            unsigned searchMatchNb = acceleration << LZ4_skipTrigger;

+        if (tableType == byPtr) {

+            const BYTE* forwardIp = ip;

+            int step = 1;

+            int searchMatchNb = acceleration << LZ4_skipTrigger;

             do {

                 U32 const h = forwardH;

                 ip = forwardIp;

                 forwardIp += step;

                 step = (searchMatchNb++ >> LZ4_skipTrigger);

-                if (unlikely(forwardIp > mflimit)) goto _last_literals;

+                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;

+                assert(ip < mflimitPlusOne);

                 match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType, base);

-                if (dict==usingExtDict) {

-                    if (match < (const BYTE*)source) {

-                        refDelta = dictDelta;

+                forwardH = LZ4_hashPosition(forwardIp, tableType);

+                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType, base);

+

+            } while ( (match+LZ4_DISTANCE_MAX < ip)

+                   || (LZ4_read32(match) != LZ4_read32(ip)) );

+

+        } else {   /* byU32, byU16 */

+

+            const BYTE* forwardIp = ip;

+            int step = 1;

+            int searchMatchNb = acceleration << LZ4_skipTrigger;

+            do {

+                U32 const h = forwardH;

+                U32 const current = (U32)(forwardIp - base);

+                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);

+                assert(matchIndex <= current);

+                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));

+                ip = forwardIp;

+                forwardIp += step;

+                step = (searchMatchNb++ >> LZ4_skipTrigger);

+

+                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;

+                assert(ip < mflimitPlusOne);

+

+                if (dictDirective == usingDictCtx) {

+                    if (matchIndex < startIndex) {

+                        /* there was no match, try the dictionary */

+                        assert(tableType == byU32);

+                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);

+                        match = dictBase + matchIndex;

+                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */

                         lowLimit = dictionary;

                     } else {

-                        refDelta = 0;

+                        match = base + matchIndex;