Coverage Report

Created: 2025-06-20 06:08

/src/lz4/lib/lz4.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
   LZ4 - Fast LZ compression algorithm
3
   Copyright (c) Yann Collet. All rights reserved.
4
5
   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
6
7
   Redistribution and use in source and binary forms, with or without
8
   modification, are permitted provided that the following conditions are
9
   met:
10
11
       * Redistributions of source code must retain the above copyright
12
   notice, this list of conditions and the following disclaimer.
13
       * Redistributions in binary form must reproduce the above
14
   copyright notice, this list of conditions and the following disclaimer
15
   in the documentation and/or other materials provided with the
16
   distribution.
17
18
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19
   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21
   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22
   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23
   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24
   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28
   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
   You can contact the author at :
31
    - LZ4 homepage : http://www.lz4.org
32
    - LZ4 source repository : https://github.com/lz4/lz4
33
*/
34
35
/*-************************************
36
*  Tuning parameters
37
**************************************/
38
/*
39
 * LZ4_HEAPMODE :
40
 * Select how stateless compression functions like `LZ4_compress_default()`
41
 * allocate memory for their hash table,
42
 * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
43
 */
44
#ifndef LZ4_HEAPMODE
45
#  define LZ4_HEAPMODE 0
46
#endif
47
48
/*
49
 * LZ4_ACCELERATION_DEFAULT :
50
 * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0
51
 */
52
0
#define LZ4_ACCELERATION_DEFAULT 1
53
/*
54
 * LZ4_ACCELERATION_MAX :
55
 * Any "acceleration" value higher than this threshold
56
 * get treated as LZ4_ACCELERATION_MAX instead (fix #876)
57
 */
58
0
#define LZ4_ACCELERATION_MAX 65537
59
60
61
/*-************************************
62
*  CPU Feature Detection
63
**************************************/
64
/* LZ4_FORCE_MEMORY_ACCESS
65
 * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
66
 * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
67
 * The below switch allow to select different access method for improved performance.
68
 * Method 0 (default) : use `memcpy()`. Safe and portable.
69
 * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
70
 *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
71
 * Method 2 : direct access. This method is portable but violate C standard.
72
 *            It can generate buggy code on targets which assembly generation depends on alignment.
73
 *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
74
 * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
75
 * Prefer these methods in priority order (0 > 1 > 2)
76
 */
77
#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
78
#  if defined(__GNUC__) && \
79
  ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \
80
  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
81
#    define LZ4_FORCE_MEMORY_ACCESS 2
82
#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__) || defined(_MSC_VER)
83
#    define LZ4_FORCE_MEMORY_ACCESS 1
84
#  endif
85
#endif
86
87
/*
88
 * LZ4_FORCE_SW_BITCOUNT
89
 * Define this parameter if your target system or compiler does not support hardware bit count
90
 */
91
#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for WinCE doesn't support Hardware bit count */
92
#  undef  LZ4_FORCE_SW_BITCOUNT  /* avoid double def */
93
#  define LZ4_FORCE_SW_BITCOUNT
94
#endif
95
96
97
98
/*-************************************
99
*  Dependency
100
**************************************/
101
/*
102
 * LZ4_SRC_INCLUDED:
103
 * Amalgamation flag, whether lz4.c is included
104
 */
105
#ifndef LZ4_SRC_INCLUDED
106
#  define LZ4_SRC_INCLUDED 1
107
#endif
108
109
#ifndef LZ4_DISABLE_DEPRECATE_WARNINGS
110
#  define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */
111
#endif
112
113
#ifndef LZ4_STATIC_LINKING_ONLY
114
#  define LZ4_STATIC_LINKING_ONLY
115
#endif
116
#include "lz4.h"
117
/* see also "memory routines" below */
118
119
120
/*-************************************
121
*  Compiler Options
122
**************************************/
123
#if defined(_MSC_VER) && (_MSC_VER >= 1400)  /* Visual Studio 2005+ */
124
#  include <intrin.h>               /* only present in VS2005+ */
125
#  pragma warning(disable : 4127)   /* disable: C4127: conditional expression is constant */
126
#  pragma warning(disable : 6237)   /* disable: C6237: conditional expression is always 0 */
127
#  pragma warning(disable : 6239)   /* disable: C6239: (<non-zero constant> && <expression>) always evaluates to the result of <expression> */
128
#  pragma warning(disable : 6240)   /* disable: C6240: (<expression> && <non-zero constant>) always evaluates to the result of <expression> */
129
#  pragma warning(disable : 6326)   /* disable: C6326: Potential comparison of a constant with another constant */
130
#endif  /* _MSC_VER */
131
132
#ifndef LZ4_FORCE_INLINE
133
#  if defined (_MSC_VER) && !defined (__clang__)    /* MSVC */
134
#    define LZ4_FORCE_INLINE static __forceinline
135
#  else
136
#    if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
137
#      if defined (__GNUC__) || defined (__clang__)
138
#        define LZ4_FORCE_INLINE static inline __attribute__((always_inline))
139
#      else
140
#        define LZ4_FORCE_INLINE static inline
141
#      endif
142
#    else
143
#      define LZ4_FORCE_INLINE static
144
#    endif /* __STDC_VERSION__ */
145
#  endif  /* _MSC_VER */
146
#endif /* LZ4_FORCE_INLINE */
147
148
/* LZ4_FORCE_O2 and LZ4_FORCE_INLINE
149
 * gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy8,
150
 * together with a simple 8-byte copy loop as a fall-back path.
151
 * However, this optimization hurts the decompression speed by >30%,
152
 * because the execution does not go to the optimized loop
153
 * for typical compressible data, and all of the preamble checks
154
 * before going to the fall-back path become useless overhead.
155
 * This optimization happens only with the -O3 flag, and -O2 generates
156
 * a simple 8-byte copy loop.
157
 * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy8
158
 * functions are annotated with __attribute__((optimize("O2"))),
159
 * and also LZ4_wildCopy8 is forcibly inlined, so that the O2 attribute
160
 * of LZ4_wildCopy8 does not affect the compression speed.
161
 */
162
#if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__) && !defined(__clang__)
163
#  define LZ4_FORCE_O2  __attribute__((optimize("O2")))
164
#  undef LZ4_FORCE_INLINE
165
#  define LZ4_FORCE_INLINE  static __inline __attribute__((optimize("O2"),always_inline))
166
#else
167
#  define LZ4_FORCE_O2
168
#endif
169
170
#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
171
208M
#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
172
#else
173
#  define expect(expr,value)    (expr)
174
#endif
175
176
#ifndef likely
177
24.6k
#define likely(expr)     expect((expr) != 0, 1)
178
#endif
179
#ifndef unlikely
180
208M
#define unlikely(expr)   expect((expr) != 0, 0)
181
#endif
182
183
/* Should the alignment test prove unreliable, for some reason,
184
 * it can be disabled by setting LZ4_ALIGN_TEST to 0 */
185
#ifndef LZ4_ALIGN_TEST  /* can be externally provided */
186
# define LZ4_ALIGN_TEST 1
187
#endif
188
189
190
/*-************************************
191
*  Memory routines
192
**************************************/
193
194
/*! LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION :
195
 *  Disable relatively high-level LZ4/HC functions that use dynamic memory
196
 *  allocation functions (malloc(), calloc(), free()).
197
 *
198
 *  Note that this is a compile-time switch. And since it disables
199
 *  public/stable LZ4 v1 API functions, we don't recommend using this
200
 *  symbol to generate a library for distribution.
201
 *
202
 *  The following public functions are removed when this symbol is defined.
203
 *  - lz4   : LZ4_createStream, LZ4_freeStream,
204
 *            LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated)
205
 *  - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC,
206
 *            LZ4_createHC (deprecated), LZ4_freeHC  (deprecated)
207
 *  - lz4frame, lz4file : All LZ4F_* functions
208
 */
209
#if defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
210
#  define ALLOC(s)          lz4_error_memory_allocation_is_disabled
211
#  define ALLOC_AND_ZERO(s) lz4_error_memory_allocation_is_disabled
212
#  define FREEMEM(p)        lz4_error_memory_allocation_is_disabled
213
#elif defined(LZ4_USER_MEMORY_FUNCTIONS)
214
/* memory management functions can be customized by user project.
215
 * Below functions must exist somewhere in the Project
216
 * and be available at link time */
217
void* LZ4_malloc(size_t s);
218
void* LZ4_calloc(size_t n, size_t s);
219
void  LZ4_free(void* p);
220
# define ALLOC(s)          LZ4_malloc(s)
221
# define ALLOC_AND_ZERO(s) LZ4_calloc(1,s)
222
# define FREEMEM(p)        LZ4_free(p)
223
#else
224
# include <stdlib.h>   /* malloc, calloc, free */
225
0
# define ALLOC(s)          malloc(s)
226
0
# define ALLOC_AND_ZERO(s) calloc(1,s)
227
0
# define FREEMEM(p)        free(p)
228
#endif
229
230
#if ! LZ4_FREESTANDING
231
#  include <string.h>   /* memset, memcpy */
232
#endif
233
#if !defined(LZ4_memset)
234
1.32k
#  define LZ4_memset(p,v,s) memset((p),(v),(s))
235
#endif
236
1.32k
#define MEM_INIT(p,v,s)   LZ4_memset((p),(v),(s))
237
238
239
/*-************************************
240
*  Common Constants
241
**************************************/
242
30.7k
#define MINMATCH 4
243
244
4.64k
#define WILDCOPYLENGTH 8
245
15.6k
#define LASTLITERALS   5   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
246
13.3k
#define MFLIMIT       12   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
247
4.15k
#define MATCH_SAFEGUARD_DISTANCE  ((2*WILDCOPYLENGTH) - MINMATCH)   /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */
248
26.7k
#define FASTLOOP_SAFE_DISTANCE 64
249
static const int LZ4_minLength = (MFLIMIT+1);
250
251
11.4k
#define KB *(1 <<10)
252
#define MB *(1 <<20)
253
0
#define GB *(1U<<30)
254
255
0
#define LZ4_DISTANCE_ABSOLUTE_MAX 65535
256
#if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX)   /* max supported by LZ4 format */
257
#  error "LZ4_DISTANCE_MAX is too big : must be <= 65535"
258
#endif
259
260
141k
#define ML_BITS  4
261
56.6k
#define ML_MASK  ((1U<<ML_BITS)-1)
262
51.1k
#define RUN_BITS (8-ML_BITS)
263
51.1k
#define RUN_MASK ((1U<<RUN_BITS)-1)
264
265
266
/*-************************************
267
*  Error detection
268
**************************************/
269
#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
270
#  include <assert.h>
271
#else
272
#  ifndef assert
273
#    define assert(condition) ((void)0)
274
#  endif
275
#endif
276
277
16.9k
#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use after variable declarations */
278
279
#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)
280
#  include <stdio.h>
281
   static int g_debuglog_enable = 1;
282
#  define DEBUGLOG(l, ...) {                          \
283
        if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
284
            fprintf(stderr, __FILE__  " %i: ", __LINE__); \
285
            fprintf(stderr, __VA_ARGS__);             \
286
            fprintf(stderr, " \n");                   \
287
    }   }
288
#else
289
160k
#  define DEBUGLOG(l, ...) {}    /* disabled */
290
#endif
291
292
static int LZ4_isAligned(const void* ptr, size_t alignment)
293
0
{
294
0
    return ((size_t)ptr & (alignment -1)) == 0;
295
0
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_isAligned
Unexecuted instantiation: lz4_helpers.c:LZ4_isAligned
Unexecuted instantiation: fuzz_data_producer.c:LZ4_isAligned
Unexecuted instantiation: lz4.c:LZ4_isAligned
Unexecuted instantiation: lz4hc.c:LZ4_isAligned
296
297
298
/*-************************************
299
*  Types
300
**************************************/
301
#include <limits.h>
302
#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
303
# include <stdint.h>
304
  typedef unsigned char BYTE; /*uint8_t not necessarily blessed to alias arbitrary type*/
305
  typedef uint16_t      U16;
306
  typedef uint32_t      U32;
307
  typedef  int32_t      S32;
308
  typedef uint64_t      U64;
309
  typedef uintptr_t     uptrval;
310
#else
311
# if UINT_MAX != 4294967295UL
312
#   error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4"
313
# endif
314
  typedef unsigned char       BYTE;
315
  typedef unsigned short      U16;
316
  typedef unsigned int        U32;
317
  typedef   signed int        S32;
318
  typedef unsigned long long  U64;
319
  typedef size_t              uptrval;   /* generally true, except OpenVMS-64 */
320
#endif
321
322
#if defined(__x86_64__)
323
  typedef U64    reg_t;   /* 64-bits in x32 mode */
324
#else
325
  typedef size_t reg_t;   /* 32-bits in x32 mode */
326
#endif
327
328
typedef enum {
329
    notLimited = 0,
330
    limitedOutput = 1,
331
    fillOutput = 2
332
} limitedOutput_directive;
333
334
335
/*-************************************
336
*  Reading and writing into memory
337
**************************************/
338
339
/**
340
 * LZ4 relies on memcpy with a constant size being inlined. In freestanding
341
 * environments, the compiler can't assume the implementation of memcpy() is
342
 * standard compliant, so it can't apply its specialized memcpy() inlining
343
 * logic. When possible, use __builtin_memcpy() to tell the compiler to analyze
344
 * memcpy() as if it were standard compliant, so it can inline it in freestanding
345
 * environments. This is needed when decompressing the Linux Kernel, for example.
346
 */
347
#if !defined(LZ4_memcpy)
348
#  if defined(__GNUC__) && (__GNUC__ >= 4)
349
79.2k
#    define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size)
350
#  else
351
#    define LZ4_memcpy(dst, src, size) memcpy(dst, src, size)
352
#  endif
353
#endif
354
355
#if !defined(LZ4_memmove)
356
#  if defined(__GNUC__) && (__GNUC__ >= 4)
357
8.59k
#    define LZ4_memmove __builtin_memmove
358
#  else
359
#    define LZ4_memmove memmove
360
#  endif
361
#endif
362
363
static unsigned LZ4_isLittleEndian(void)
364
26.8k
{
365
26.8k
    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
366
26.8k
    return one.c[0];
367
26.8k
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_isLittleEndian
Unexecuted instantiation: lz4_helpers.c:LZ4_isLittleEndian
Unexecuted instantiation: fuzz_data_producer.c:LZ4_isLittleEndian
lz4.c:LZ4_isLittleEndian
Line
Count
Source
364
26.8k
{
365
26.8k
    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
366
26.8k
    return one.c[0];
367
26.8k
}
Unexecuted instantiation: lz4hc.c:LZ4_isLittleEndian
368
369
#if defined(__GNUC__) || defined(__INTEL_COMPILER)
370
#define LZ4_PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__))
371
#elif defined(_MSC_VER)
372
#define LZ4_PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop))
373
#endif
374
375
#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
376
/* lie to the compiler about data alignment; use with caution */
377
378
static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; }
379
static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; }
380
static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; }
381
382
static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
383
static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
384
385
#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
386
387
/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
388
/* currently only defined for gcc and icc */
389
LZ4_PACK(typedef struct { U16 u16; }) LZ4_unalign16;
390
LZ4_PACK(typedef struct { U32 u32; }) LZ4_unalign32;
391
LZ4_PACK(typedef struct { reg_t uArch; }) LZ4_unalignST;
392
393
26.8k
static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign16*)ptr)->u16; }
Unexecuted instantiation: decompress_fuzzer.c:LZ4_read16
Unexecuted instantiation: lz4_helpers.c:LZ4_read16
Unexecuted instantiation: fuzz_data_producer.c:LZ4_read16
lz4.c:LZ4_read16
Line
Count
Source
393
26.8k
static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign16*)ptr)->u16; }
Unexecuted instantiation: lz4hc.c:LZ4_read16
394
0
static U32 LZ4_read32(const void* ptr) { return ((const LZ4_unalign32*)ptr)->u32; }
Unexecuted instantiation: decompress_fuzzer.c:LZ4_read32
Unexecuted instantiation: lz4_helpers.c:LZ4_read32
Unexecuted instantiation: fuzz_data_producer.c:LZ4_read32
Unexecuted instantiation: lz4.c:LZ4_read32
Unexecuted instantiation: lz4hc.c:LZ4_read32
395
0
static reg_t LZ4_read_ARCH(const void* ptr) { return ((const LZ4_unalignST*)ptr)->uArch; }
Unexecuted instantiation: decompress_fuzzer.c:LZ4_read_ARCH
Unexecuted instantiation: lz4_helpers.c:LZ4_read_ARCH
Unexecuted instantiation: fuzz_data_producer.c:LZ4_read_ARCH
Unexecuted instantiation: lz4.c:LZ4_read_ARCH
Unexecuted instantiation: lz4hc.c:LZ4_read_ARCH
396
397
0
static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign16*)memPtr)->u16 = value; }
Unexecuted instantiation: decompress_fuzzer.c:LZ4_write16
Unexecuted instantiation: lz4_helpers.c:LZ4_write16
Unexecuted instantiation: fuzz_data_producer.c:LZ4_write16
Unexecuted instantiation: lz4.c:LZ4_write16
Unexecuted instantiation: lz4hc.c:LZ4_write16
398
10.1k
static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign32*)memPtr)->u32 = value; }
Unexecuted instantiation: decompress_fuzzer.c:LZ4_write32
Unexecuted instantiation: lz4_helpers.c:LZ4_write32
Unexecuted instantiation: fuzz_data_producer.c:LZ4_write32
lz4.c:LZ4_write32
Line
Count
Source
398
10.1k
static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign32*)memPtr)->u32 = value; }
Unexecuted instantiation: lz4hc.c:LZ4_write32
399
400
#else  /* safe and portable access using memcpy() */
401
402
static U16 LZ4_read16(const void* memPtr)
403
{
404
    U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
405
}
406
407
static U32 LZ4_read32(const void* memPtr)
408
{
409
    U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
410
}
411
412
static reg_t LZ4_read_ARCH(const void* memPtr)
413
{
414
    reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
415
}
416
417
static void LZ4_write16(void* memPtr, U16 value)
418
{
419
    LZ4_memcpy(memPtr, &value, sizeof(value));
420
}
421
422
static void LZ4_write32(void* memPtr, U32 value)
423
{
424
    LZ4_memcpy(memPtr, &value, sizeof(value));
425
}
426
427
#endif /* LZ4_FORCE_MEMORY_ACCESS */
428
429
430
static U16 LZ4_readLE16(const void* memPtr)
431
26.8k
{
432
26.8k
    if (LZ4_isLittleEndian()) {
433
26.8k
        return LZ4_read16(memPtr);
434
26.8k
    } else {
435
0
        const BYTE* p = (const BYTE*)memPtr;
436
0
        return (U16)((U16)p[0] | (p[1]<<8));
437
0
    }
438
26.8k
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_readLE16
Unexecuted instantiation: lz4_helpers.c:LZ4_readLE16
Unexecuted instantiation: fuzz_data_producer.c:LZ4_readLE16
lz4.c:LZ4_readLE16
Line
Count
Source
431
26.8k
{
432
26.8k
    if (LZ4_isLittleEndian()) {
433
26.8k
        return LZ4_read16(memPtr);
434
26.8k
    } else {
435
0
        const BYTE* p = (const BYTE*)memPtr;
436
0
        return (U16)((U16)p[0] | (p[1]<<8));
437
0
    }
438
26.8k
}
Unexecuted instantiation: lz4hc.c:LZ4_readLE16
439
440
#ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT
441
static U32 LZ4_readLE32(const void* memPtr)
442
{
443
    if (LZ4_isLittleEndian()) {
444
        return LZ4_read32(memPtr);
445
    } else {
446
        const BYTE* p = (const BYTE*)memPtr;
447
        return (U32)p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);
448
    }
449
}
450
#endif
451
452
static void LZ4_writeLE16(void* memPtr, U16 value)
453
0
{
454
0
    if (LZ4_isLittleEndian()) {
455
0
        LZ4_write16(memPtr, value);
456
0
    } else {
457
0
        BYTE* p = (BYTE*)memPtr;
458
0
        p[0] = (BYTE) value;
459
0
        p[1] = (BYTE)(value>>8);
460
0
    }
461
0
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_writeLE16
Unexecuted instantiation: lz4_helpers.c:LZ4_writeLE16
Unexecuted instantiation: fuzz_data_producer.c:LZ4_writeLE16
Unexecuted instantiation: lz4.c:LZ4_writeLE16
Unexecuted instantiation: lz4hc.c:LZ4_writeLE16
462
463
/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
464
LZ4_FORCE_INLINE
465
void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)
466
13.0k
{
467
13.0k
    BYTE* d = (BYTE*)dstPtr;
468
13.0k
    const BYTE* s = (const BYTE*)srcPtr;
469
13.0k
    BYTE* const e = (BYTE*)dstEnd;
470
471
21.4k
    do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
472
13.0k
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_wildCopy8
Unexecuted instantiation: lz4_helpers.c:LZ4_wildCopy8
Unexecuted instantiation: fuzz_data_producer.c:LZ4_wildCopy8
lz4.c:LZ4_wildCopy8
Line
Count
Source
466
13.0k
{
467
13.0k
    BYTE* d = (BYTE*)dstPtr;
468
13.0k
    const BYTE* s = (const BYTE*)srcPtr;
469
13.0k
    BYTE* const e = (BYTE*)dstEnd;
470
471
21.4k
    do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
472
13.0k
}
Unexecuted instantiation: lz4hc.c:LZ4_wildCopy8
473
474
static const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};
475
static const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
476
477
478
#ifndef LZ4_FAST_DEC_LOOP
479
#  if defined __i386__ || defined _M_IX86 || defined __x86_64__ || defined _M_X64
480
#    define LZ4_FAST_DEC_LOOP 1
481
#  elif defined(__aarch64__)
482
#    if defined(__clang__) && defined(__ANDROID__)
483
     /* On Android aarch64, we disable this optimization for clang because
484
      * on certain mobile chipsets, performance is reduced with clang. For
485
      * more information refer to https://github.com/lz4/lz4/pull/707 */
486
#      define LZ4_FAST_DEC_LOOP 0
487
#    else
488
#      define LZ4_FAST_DEC_LOOP 1
489
#    endif
490
#  else
491
#    define LZ4_FAST_DEC_LOOP 0
492
#  endif
493
#endif
494
495
#if LZ4_FAST_DEC_LOOP
496
497
LZ4_FORCE_INLINE void
498
LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
499
5.67k
{
500
5.67k
    assert(srcPtr + offset == dstPtr);
501
5.67k
    if (offset < 8) {
502
5.23k
        LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */
503
5.23k
        dstPtr[0] = srcPtr[0];
504
5.23k
        dstPtr[1] = srcPtr[1];
505
5.23k
        dstPtr[2] = srcPtr[2];
506
5.23k
        dstPtr[3] = srcPtr[3];
507
5.23k
        srcPtr += inc32table[offset];
508
5.23k
        LZ4_memcpy(dstPtr+4, srcPtr, 4);
509
5.23k
        srcPtr -= dec64table[offset];
510
5.23k
        dstPtr += 8;
511
5.23k
    } else {
512
444
        LZ4_memcpy(dstPtr, srcPtr, 8);
513
444
        dstPtr += 8;
514
444
        srcPtr += 8;
515
444
    }
516
517
5.67k
    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);
518
5.67k
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_memcpy_using_offset_base
Unexecuted instantiation: lz4_helpers.c:LZ4_memcpy_using_offset_base
Unexecuted instantiation: fuzz_data_producer.c:LZ4_memcpy_using_offset_base
lz4.c:LZ4_memcpy_using_offset_base
Line
Count
Source
499
5.67k
{
500
5.67k
    assert(srcPtr + offset == dstPtr);
501
5.67k
    if (offset < 8) {
502
5.23k
        LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */
503
5.23k
        dstPtr[0] = srcPtr[0];
504
5.23k
        dstPtr[1] = srcPtr[1];
505
5.23k
        dstPtr[2] = srcPtr[2];
506
5.23k
        dstPtr[3] = srcPtr[3];
507
5.23k
        srcPtr += inc32table[offset];
508
5.23k
        LZ4_memcpy(dstPtr+4, srcPtr, 4);
509
5.23k
        srcPtr -= dec64table[offset];
510
5.23k
        dstPtr += 8;
511
5.23k
    } else {
512
444
        LZ4_memcpy(dstPtr, srcPtr, 8);
513
444
        dstPtr += 8;
514
444
        srcPtr += 8;
515
444
    }
516
517
5.67k
    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);
518
5.67k
}
Unexecuted instantiation: lz4hc.c:LZ4_memcpy_using_offset_base
519
520
/* customized variant of memcpy, which can overwrite up to 32 bytes beyond dstEnd
521
 * this version copies two times 16 bytes (instead of one time 32 bytes)
522
 * because it must be compatible with offsets >= 16. */
523
LZ4_FORCE_INLINE void
524
LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)
525
2.48k
{
526
2.48k
    BYTE* d = (BYTE*)dstPtr;
527
2.48k
    const BYTE* s = (const BYTE*)srcPtr;
528
2.48k
    BYTE* const e = (BYTE*)dstEnd;
529
530
3.60k
    do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
531
2.48k
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_wildCopy32
Unexecuted instantiation: lz4_helpers.c:LZ4_wildCopy32
Unexecuted instantiation: fuzz_data_producer.c:LZ4_wildCopy32
lz4.c:LZ4_wildCopy32
Line
Count
Source
525
2.48k
{
526
2.48k
    BYTE* d = (BYTE*)dstPtr;
527
2.48k
    const BYTE* s = (const BYTE*)srcPtr;
528
2.48k
    BYTE* const e = (BYTE*)dstEnd;
529
530
3.60k
    do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
531
2.48k
}
Unexecuted instantiation: lz4hc.c:LZ4_wildCopy32
532
533
/* LZ4_memcpy_using_offset()  presumes :
534
 * - dstEnd >= dstPtr + MINMATCH
535
 * - there is at least 12 bytes available to write after dstEnd */
536
LZ4_FORCE_INLINE void
537
LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
538
9.04k
{
539
9.04k
    BYTE v[8];
540
541
9.04k
    assert(dstEnd >= dstPtr + MINMATCH);
542
543
9.04k
    switch(offset) {
544
1.32k
    case 1:
545
1.32k
        MEM_INIT(v, *srcPtr, 8);
546
1.32k
        break;
547
848
    case 2:
548
848
        LZ4_memcpy(v, srcPtr, 2);
549
848
        LZ4_memcpy(&v[2], srcPtr, 2);
550
#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
551
#  pragma warning(push)
552
#  pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */
553
#endif
554
848
        LZ4_memcpy(&v[4], v, 4);
555
#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
556
#  pragma warning(pop)
557
#endif
558
848
        break;
559
1.19k
    case 4:
560
1.19k
        LZ4_memcpy(v, srcPtr, 4);
561
1.19k
        LZ4_memcpy(&v[4], srcPtr, 4);
562
1.19k
        break;
563
5.67k
    default:
564
5.67k
        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
565
5.67k
        return;
566
9.04k
    }
567
568
3.36k
    LZ4_memcpy(dstPtr, v, 8);
569
3.36k
    dstPtr += 8;
570
4.77k
    while (dstPtr < dstEnd) {
571
1.40k
        LZ4_memcpy(dstPtr, v, 8);
572
1.40k
        dstPtr += 8;
573
1.40k
    }
574
3.36k
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_memcpy_using_offset
Unexecuted instantiation: lz4_helpers.c:LZ4_memcpy_using_offset
Unexecuted instantiation: fuzz_data_producer.c:LZ4_memcpy_using_offset
lz4.c:LZ4_memcpy_using_offset
Line
Count
Source
538
9.04k
{
539
9.04k
    BYTE v[8];
540
541
9.04k
    assert(dstEnd >= dstPtr + MINMATCH);
542
543
9.04k
    switch(offset) {
544
1.32k
    case 1:
545
1.32k
        MEM_INIT(v, *srcPtr, 8);
546
1.32k
        break;
547
848
    case 2:
548
848
        LZ4_memcpy(v, srcPtr, 2);
549
848
        LZ4_memcpy(&v[2], srcPtr, 2);
550
#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
551
#  pragma warning(push)
552
#  pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */
553
#endif
554
848
        LZ4_memcpy(&v[4], v, 4);
555
#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
556
#  pragma warning(pop)
557
#endif
558
848
        break;
559
1.19k
    case 4:
560
1.19k
        LZ4_memcpy(v, srcPtr, 4);
561
1.19k
        LZ4_memcpy(&v[4], srcPtr, 4);
562
1.19k
        break;
563
5.67k
    default:
564
5.67k
        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
565
5.67k
        return;
566
9.04k
    }
567
568
3.36k
    LZ4_memcpy(dstPtr, v, 8);
569
3.36k
    dstPtr += 8;
570
4.77k
    while (dstPtr < dstEnd) {
571
1.40k
        LZ4_memcpy(dstPtr, v, 8);
572
1.40k
        dstPtr += 8;
573
1.40k
    }
574
3.36k
}
Unexecuted instantiation: lz4hc.c:LZ4_memcpy_using_offset
575
#endif
576
577
578
/*-************************************
579
*  Common functions
580
**************************************/
581
static unsigned LZ4_NbCommonBytes (reg_t val)
582
0
{
583
0
    assert(val != 0);
584
0
    if (LZ4_isLittleEndian()) {
585
0
        if (sizeof(val) == 8) {
586
#       if defined(_MSC_VER) && (_MSC_VER >= 1800) && (defined(_M_AMD64) && !defined(_M_ARM64EC)) && !defined(LZ4_FORCE_SW_BITCOUNT)
587
/*-*************************************************************************************************
588
* ARM64EC is a Microsoft-designed ARM64 ABI compatible with AMD64 applications on ARM64 Windows 11.
589
* The ARM64EC ABI does not support AVX/AVX2/AVX512 instructions, nor their relevant intrinsics
590
* including _tzcnt_u64. Therefore, we need to neuter the _tzcnt_u64 code path for ARM64EC.
591
****************************************************************************************************/
592
#         if defined(__clang__) && (__clang_major__ < 10)
593
            /* Avoid undefined clang-cl intrinsics issue.
594
             * See https://github.com/lz4/lz4/pull/1017 for details. */
595
            return (unsigned)__builtin_ia32_tzcnt_u64(val) >> 3;
596
#         else
597
            /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */
598
            return (unsigned)_tzcnt_u64(val) >> 3;
599
#         endif
600
#       elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
601
            unsigned long r = 0;
602
            _BitScanForward64(&r, (U64)val);
603
            return (unsigned)r >> 3;
604
#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
605
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
606
                                        !defined(LZ4_FORCE_SW_BITCOUNT)
607
            return (unsigned)__builtin_ctzll((U64)val) >> 3;
608
#       else
609
            const U64 m = 0x0101010101010101ULL;
610
            val ^= val - 1;
611
            return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56);
612
#       endif
613
0
        } else /* 32 bits */ {
614
#       if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
615
            unsigned long r;
616
            _BitScanForward(&r, (U32)val);
617
            return (unsigned)r >> 3;
618
#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
619
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
620
                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
621
            return (unsigned)__builtin_ctz((U32)val) >> 3;
622
#       else
623
            const U32 m = 0x01010101;
624
            return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
625
#       endif
626
0
        }
627
0
    } else   /* Big Endian CPU */ {
628
0
        if (sizeof(val)==8) {
629
0
#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
630
0
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
631
0
                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
632
0
            return (unsigned)__builtin_clzll((U64)val) >> 3;
633
#       else
634
#if 1
635
            /* this method is probably faster,
636
             * but adds a 128 bytes lookup table */
637
            static const unsigned char ctz7_tab[128] = {
638
                7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
639
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
640
                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
641
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
642
                6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
643
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
644
                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
645
                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
646
            };
647
            U64 const mask = 0x0101010101010101ULL;
648
            U64 const t = (((val >> 8) - mask) | val) & mask;
649
            return ctz7_tab[(t * 0x0080402010080402ULL) >> 57];
650
#else
651
            /* this method doesn't consume memory space like the previous one,
652
             * but it contains several branches,
653
             * that may end up slowing execution */
654
            static const U32 by32 = sizeof(val)*4;  /* 32 on 64 bits (goal), 16 on 32 bits.
655
            Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.
656
            Note that this code path is never triggered in 32-bits mode. */
657
            unsigned r;
658
            if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }
659
            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
660
            r += (!val);
661
            return r;
662
#endif
663
#       endif
664
0
        } else /* 32 bits */ {
665
0
#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
666
0
                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
667
0
                                        !defined(LZ4_FORCE_SW_BITCOUNT)
668
0
            return (unsigned)__builtin_clz((U32)val) >> 3;
669
#       else
670
            val >>= 8;
671
            val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |
672
              (val + 0x00FF0000)) >> 24;
673
            return (unsigned)val ^ 3;
674
#       endif
675
0
        }
676
0
    }
677
0
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_NbCommonBytes
Unexecuted instantiation: lz4_helpers.c:LZ4_NbCommonBytes
Unexecuted instantiation: fuzz_data_producer.c:LZ4_NbCommonBytes
Unexecuted instantiation: lz4.c:LZ4_NbCommonBytes
Unexecuted instantiation: lz4hc.c:LZ4_NbCommonBytes
678
679
680
0
#define STEPSIZE sizeof(reg_t)
681
LZ4_FORCE_INLINE
682
unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
683
0
{
684
0
    const BYTE* const pStart = pIn;
685
686
0
    if (likely(pIn < pInLimit-(STEPSIZE-1))) {
687
0
        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
688
0
        if (!diff) {
689
0
            pIn+=STEPSIZE; pMatch+=STEPSIZE;
690
0
        } else {
691
0
            return LZ4_NbCommonBytes(diff);
692
0
    }   }
693
694
0
    while (likely(pIn < pInLimit-(STEPSIZE-1))) {
695
0
        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
696
0
        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
697
0
        pIn += LZ4_NbCommonBytes(diff);
698
0
        return (unsigned)(pIn - pStart);
699
0
    }
700
701
0
    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
702
0
    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
703
0
    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
704
0
    return (unsigned)(pIn - pStart);
705
0
}
Unexecuted instantiation: decompress_fuzzer.c:LZ4_count
Unexecuted instantiation: lz4_helpers.c:LZ4_count
Unexecuted instantiation: fuzz_data_producer.c:LZ4_count
Unexecuted instantiation: lz4.c:LZ4_count
Unexecuted instantiation: lz4hc.c:LZ4_count
706
707
708
#ifndef LZ4_COMMONDEFS_ONLY
709
/*-************************************
710
*  Local Constants
711
**************************************/
712
static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
713
static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression run slower on incompressible data */
714
715
716
/*-************************************
717
*  Local Structures and types
718
**************************************/
719
typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t;
720
721
/**
722
 * This enum distinguishes several different modes of accessing previous
723
 * content in the stream.
724
 *
725
 * - noDict        : There is no preceding content.
726
 * - withPrefix64k : Table entries up to ctx->dictSize before the current blob
727
 *                   blob being compressed are valid and refer to the preceding
728
 *                   content (of length ctx->dictSize), which is available
729
 *                   contiguously preceding in memory the content currently
730
 *                   being compressed.
731
 * - usingExtDict  : Like withPrefix64k, but the preceding content is somewhere
732
 *                   else in memory, starting at ctx->dictionary with length
733
 *                   ctx->dictSize.
734
 * - usingDictCtx  : Everything concerning the preceding content is
735
 *                   in a separate context, pointed to by ctx->dictCtx.
736
 *                   ctx->dictionary, ctx->dictSize, and table entries
737
 *                   in the current context that refer to positions
738
 *                   preceding the beginning of the current compression are
739
 *                   ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx
740
 *                   ->dictSize describe the location and size of the preceding
741
 *                   content, and matches are found by looking in the ctx
742
 *                   ->dictCtx->hashTable.
743
 */
744
typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;
745
typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
746
747
748
/*-************************************
749
*  Local Utils
750
**************************************/
751
0
int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; }
752
0
const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; }
753
0
int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }
754
0
int LZ4_sizeofState(void) { return sizeof(LZ4_stream_t); }
755
756
757
/*-****************************************
758
*  Internal Definitions, used only in Tests
759
*******************************************/
760
#if defined (__cplusplus)
761
extern "C" {
762
#endif
763
764
int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize);
765
766
int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
767
                                     int compressedSize, int maxOutputSize,
768
                                     const void* dictStart, size_t dictSize);
769
int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
770
                                     int compressedSize, int targetOutputSize, int dstCapacity,
771
                                     const void* dictStart, size_t dictSize);
772
#if defined (__cplusplus)
773
}
774
#endif
775
776
/*-******************************
777
*  Compression functions
778
********************************/
779
LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
780
0
{
781
0
    if (tableType == byU16)
782
0
        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
783
0
    else
784
0
        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
785
0
}
786
787
LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
788
0
{
789
0
    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
790
0
    if (LZ4_isLittleEndian()) {
791
0
        const U64 prime5bytes = 889523592379ULL;
792
0
        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
793
0
    } else {
794
0
        const U64 prime8bytes = 11400714785074694791ULL;
795
0
        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
796
0
    }
797
0
}
798
799
LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
800
0
{
801
0
    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
802
803
#ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT
804
    return LZ4_hash4(LZ4_readLE32(p), tableType);
805
#else
806
0
    return LZ4_hash4(LZ4_read32(p), tableType);
807
0
#endif
808
0
}
809
810
LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)
811
0
{
812
0
    switch (tableType)
813
0
    {
814
0
    default: /* fallthrough */
815
0
    case clearedTable: { /* illegal! */ assert(0); return; }
816
0
    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
817
0
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
818
0
    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
819
0
    }
820
0
}
821
822
LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
823
0
{
824
0
    switch (tableType)
825
0
    {
826
0
    default: /* fallthrough */
827
0
    case clearedTable: /* fallthrough */
828
0
    case byPtr: { /* illegal! */ assert(0); return; }
829
0
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
830
0
    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
831
0
    }
832
0
}
833
834
/* LZ4_putPosition*() : only used in byPtr mode */
835
LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h,
836
                                  void* tableBase, tableType_t const tableType)
837
0
{
838
0
    const BYTE** const hashTable = (const BYTE**)tableBase;
839
0
    assert(tableType == byPtr); (void)tableType;
840
0
    hashTable[h] = p;
841
0
}
842
843
LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType)
844
0
{
845
0
    U32 const h = LZ4_hashPosition(p, tableType);
846
0
    LZ4_putPositionOnHash(p, h, tableBase, tableType);
847
0
}
848
849
/* LZ4_getIndexOnHash() :
850
 * Index of match position registered in hash table.
851
 * hash position must be calculated by using base+index, or dictBase+index.
852
 * Assumption 1 : only valid if tableType == byU32 or byU16.
853
 * Assumption 2 : h is presumed valid (within limits of hash table)
854
 */
855
LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
856
0
{
857
0
    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
858
0
    if (tableType == byU32) {
859
0
        const U32* const hashTable = (const U32*) tableBase;
860
0
        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
861
0
        return hashTable[h];
862
0
    }
863
0
    if (tableType == byU16) {
864
0
        const U16* const hashTable = (const U16*) tableBase;
865
0
        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
866
0
        return hashTable[h];
867
0
    }
868
0
    assert(0); return 0;  /* forbidden case */
869
0
}
870
871
static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType)
872
0
{
873
0
    assert(tableType == byPtr); (void)tableType;
874
0
    { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }
875
0
}
876
877
LZ4_FORCE_INLINE const BYTE*
878
LZ4_getPosition(const BYTE* p,
879
                const void* tableBase, tableType_t tableType)
880
0
{
881
0
    U32 const h = LZ4_hashPosition(p, tableType);
882
0
    return LZ4_getPositionOnHash(h, tableBase, tableType);
883
0
}
884
885
LZ4_FORCE_INLINE void
886
LZ4_prepareTable(LZ4_stream_t_internal* const cctx,
887
           const int inputSize,
888
0
           const tableType_t tableType) {
889
    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is
890
     * therefore safe to use no matter what mode we're in. Otherwise, we figure
891
     * out if it's safe to leave as is or whether it needs to be reset.
892
     */
893
0
    if ((tableType_t)cctx->tableType != clearedTable) {
894
0
        assert(inputSize >= 0);
895
0
        if ((tableType_t)cctx->tableType != tableType
896
0
          || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)
897
0
          || ((tableType == byU32) && cctx->currentOffset > 1 GB)
898
0
          || tableType == byPtr
899
0
          || inputSize >= 4 KB)
900
0
        {
901
0
            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", (void*)cctx);
902
0
            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
903
0
            cctx->currentOffset = 0;
904
0
            cctx->tableType = (U32)clearedTable;
905
0
        } else {
906
0
            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");
907
0
        }
908
0
    }
909
910
    /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back,
911
     * is faster than compressing without a gap.
912
     * However, compressing with currentOffset == 0 is faster still,
913
     * so we preserve that case.
914
     */
915
0
    if (cctx->currentOffset != 0 && tableType == byU32) {
916
0
        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");
917
0
        cctx->currentOffset += 64 KB;
918
0
    }
919
920
    /* Finally, clear history */
921
0
    cctx->dictCtx = NULL;
922
0
    cctx->dictionary = NULL;
923
0
    cctx->dictSize = 0;
924
0
}
925
926
/** LZ4_compress_generic_validated() :
927
 *  inlined, to ensure branches are decided at compilation time.
928
 *  The following conditions are presumed already validated:
929
 *  - source != NULL
930
 *  - inputSize > 0
931
 */
932
LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
933
                 LZ4_stream_t_internal* const cctx,
934
                 const char* const source,
935
                 char* const dest,
936
                 const int inputSize,
937
                 int*  inputConsumed, /* only written when outputDirective == fillOutput */
938
                 const int maxOutputSize,
939
                 const limitedOutput_directive outputDirective,
940
                 const tableType_t tableType,
941
                 const dict_directive dictDirective,
942
                 const dictIssue_directive dictIssue,
943
                 const int acceleration)
944
0
{
945
0
    int result;
946
0
    const BYTE* ip = (const BYTE*)source;
947
948
0
    U32 const startIndex = cctx->currentOffset;
949
0
    const BYTE* base = (const BYTE*)source - startIndex;
950
0
    const BYTE* lowLimit;
951
952
0
    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;
953
0
    const BYTE* const dictionary =
954
0
        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;
955
0
    const U32 dictSize =
956
0
        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;
957
0
    const U32 dictDelta =
958
0
        (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with indexes in current context */
959
960
0
    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);
961
0
    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */
962
0
    const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary;
963
0
    const BYTE* anchor = (const BYTE*) source;
964
0
    const BYTE* const iend = ip + inputSize;
965
0
    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;
966
0
    const BYTE* const matchlimit = iend - LASTLITERALS;
967
968
    /* the dictCtx currentOffset is indexed on the start of the dictionary,
969
     * while a dictionary in the current context precedes the currentOffset */
970
0
    const BYTE* dictBase = (dictionary == NULL) ? NULL :
971
0
                           (dictDirective == usingDictCtx) ?
972
0
                            dictionary + dictSize - dictCtx->currentOffset :
973
0
                            dictionary + dictSize - startIndex;
974
975
0
    BYTE* op = (BYTE*) dest;
976
0
    BYTE* const olimit = op + maxOutputSize;
977
978
0
    U32 offset = 0;
979
0
    U32 forwardH;
980
981
0
    DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType);
982
0
    assert(ip != NULL);
983
0
    if (tableType == byU16) assert(inputSize<LZ4_64Klimit);  /* Size too large (not within 64K limit) */
984
0
    if (tableType == byPtr) assert(dictDirective==noDict);   /* only supported use case with byPtr */
985
    /* If init conditions are not met, we don't have to mark stream
986
     * as having dirty context, since no action was taken yet */
987
0
    if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */
988
0
    assert(acceleration >= 1);
989
990
0
    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);
991
992
    /* Update context state */
993
0
    if (dictDirective == usingDictCtx) {
994
        /* Subsequent linked blocks can't use the dictionary. */
995
        /* Instead, they use the block we just compressed. */
996
0
        cctx->dictCtx = NULL;
997
0
        cctx->dictSize = (U32)inputSize;
998
0
    } else {
999
0
        cctx->dictSize += (U32)inputSize;
1000
0
    }
1001
0
    cctx->currentOffset += (U32)inputSize;
1002
0
    cctx->tableType = (U32)tableType;
1003
1004
0
    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */
1005
1006
    /* First Byte */
1007
0
    {   U32 const h = LZ4_hashPosition(ip, tableType);
1008
0
        if (tableType == byPtr) {
1009
0
            LZ4_putPositionOnHash(ip, h, cctx->hashTable, byPtr);
1010
0
        } else {
1011
0
            LZ4_putIndexOnHash(startIndex, h, cctx->hashTable, tableType);
1012
0
    }   }
1013
0
    ip++; forwardH = LZ4_hashPosition(ip, tableType);
1014
1015
    /* Main Loop */
1016
0
    for ( ; ; ) {
1017
0
        const BYTE* match;
1018
0
        BYTE* token;
1019
0
        const BYTE* filledIp;
1020
1021
        /* Find a match */
1022
0
        if (tableType == byPtr) {
1023
0
            const BYTE* forwardIp = ip;
1024
0
            int step = 1;
1025
0
            int searchMatchNb = acceleration << LZ4_skipTrigger;
1026
0
            do {
1027
0
                U32 const h = forwardH;
1028
0
                ip = forwardIp;
1029
0
                forwardIp += step;
1030
0
                step = (searchMatchNb++ >> LZ4_skipTrigger);
1031
1032
0
                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
1033
0
                assert(ip < mflimitPlusOne);
1034
1035
0
                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType);
1036
0
                forwardH = LZ4_hashPosition(forwardIp, tableType);
1037
0
                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType);
1038
1039
0
            } while ( (match+LZ4_DISTANCE_MAX < ip)
1040
0
                   || (LZ4_read32(match) != LZ4_read32(ip)) );
1041
1042
0
        } else {   /* byU32, byU16 */
1043
1044
0
            const BYTE* forwardIp = ip;
1045
0
            int step = 1;
1046
0
            int searchMatchNb = acceleration << LZ4_skipTrigger;
1047
0
            do {
1048
0
                U32 const h = forwardH;
1049
0
                U32 const current = (U32)(forwardIp - base);
1050
0
                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
1051
0
                assert(matchIndex <= current);
1052
0
                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));
1053
0
                ip = forwardIp;
1054
0
                forwardIp += step;
1055
0
                step = (searchMatchNb++ >> LZ4_skipTrigger);
1056
1057
0
                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
1058
0
                assert(ip < mflimitPlusOne);
1059
1060
0
                if (dictDirective == usingDictCtx) {
1061
0
                    if (matchIndex < startIndex) {
1062
                        /* there was no match, try the dictionary */
1063
0
                        assert(tableType == byU32);
1064
0
                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
1065
0
                        match = dictBase + matchIndex;
1066
0
                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */
1067
0
                        lowLimit = dictionary;
1068
0
                    } else {
1069
0
                        match = base + matchIndex;
1070
0
                        lowLimit = (const BYTE*)source;
1071
0
                    }
1072
0
                } else if (dictDirective == usingExtDict) {
1073
0
                    if (matchIndex < startIndex) {
1074
0
                        DEBUGLOG(7, "extDict candidate: matchIndex=%5u  <  startIndex=%5u", matchIndex, startIndex);
1075
0
                        assert(startIndex - matchIndex >= MINMATCH);
1076
0
                        assert(dictBase);
1077
0
                        match = dictBase + matchIndex;
1078
0
                        lowLimit = dictionary;
1079
0
                    } else {
1080
0
                        match = base + matchIndex;
1081
0
                        lowLimit = (const BYTE*)source;
1082
0
                    }
1083
0
                } else {   /* single continuous memory segment */
1084
0
                    match = base + matchIndex;
1085
0
                }
1086
0
                forwardH = LZ4_hashPosition(forwardIp, tableType);
1087
0
                LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
1088
1089
0
                DEBUGLOG(7, "candidate at pos=%u  (offset=%u \n", matchIndex, current - matchIndex);
1090
0
                if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; }    /* match outside of valid area */
1091
0
                assert(matchIndex < current);
1092
0
                if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX))
1093
0
                  && (matchIndex+LZ4_DISTANCE_MAX < current)) {
1094
0
                    continue;
1095
0
                } /* too far */
1096
0
                assert((current - matchIndex) <= LZ4_DISTANCE_MAX);  /* match now expected within distance */
1097
1098
0
                if (LZ4_read32(match) == LZ4_read32(ip)) {
1099
0
                    if (maybe_extMem) offset = current - matchIndex;
1100
0
                    break;   /* match found */
1101
0
                }
1102
1103
0
            } while(1);
1104
0
        }
1105
1106
        /* Catch up */
1107
0
        filledIp = ip;
1108
0
        assert(ip > anchor); /* this is always true as ip has been advanced before entering the main loop */
1109
0
        if ((match > lowLimit) && unlikely(ip[-1] == match[-1])) {
1110
0
            do { ip--; match--; } while (((ip > anchor) & (match > lowLimit)) && (unlikely(ip[-1] == match[-1])));
1111
0
        }
1112
1113
        /* Encode Literals */
1114
0
        {   unsigned const litLength = (unsigned)(ip - anchor);
1115
0
            token = op++;
1116
0
            if ((outputDirective == limitedOutput) &&  /* Check output buffer overflow */
1117
0
                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) {
1118
0
                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
1119
0
            }
1120
0
            if ((outputDirective == fillOutput) &&
1121
0
                (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) {
1122
0
                op--;
1123
0
                goto _last_literals;
1124
0
            }
1125
0
            if (litLength >= RUN_MASK) {
1126
0
                unsigned len = litLength - RUN_MASK;
1127
0
                *token = (RUN_MASK<<ML_BITS);
1128
0
                for(; len >= 255 ; len-=255) *op++ = 255;
1129
0
                *op++ = (BYTE)len;
1130
0
            }
1131
0
            else *token = (BYTE)(litLength<<ML_BITS);
1132
1133
            /* Copy Literals */
1134
0
            LZ4_wildCopy8(op, anchor, op+litLength);
1135
0
            op+=litLength;
1136
0
            DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
1137
0
                        (int)(anchor-(const BYTE*)source), litLength, (int)(ip-(const BYTE*)source));
1138
0
        }
1139
1140
0
_next_match:
1141
        /* at this stage, the following variables must be correctly set :
1142
         * - ip : at start of LZ operation
1143
         * - match : at start of previous pattern occurrence; can be within current prefix, or within extDict
1144
         * - offset : if maybe_ext_memSegment==1 (constant)
1145
         * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise
1146
         * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written
1147
         */
1148
1149
0
        if ((outputDirective == fillOutput) &&
1150
0
            (op + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit)) {
1151
            /* the match was too close to the end, rewind and go to last literals */
1152
0
            op = token;
1153
0
            goto _last_literals;
1154
0
        }
1155
1156
        /* Encode Offset */
1157
0
        if (maybe_extMem) {   /* static test */
1158
0
            DEBUGLOG(6, "             with offset=%u  (ext if > %i)", offset, (int)(ip - (const BYTE*)source));
1159
0
            assert(offset <= LZ4_DISTANCE_MAX && offset > 0);
1160
0
            LZ4_writeLE16(op, (U16)offset); op+=2;
1161
0
        } else  {
1162
0
            DEBUGLOG(6, "             with offset=%u  (same segment)", (U32)(ip - match));
1163
0
            assert(ip-match <= LZ4_DISTANCE_MAX);
1164
0
            LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
1165
0
        }
1166
1167
        /* Encode MatchLength */
1168
0
        {   unsigned matchCode;
1169
1170
0
            if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx)
1171
0
              && (lowLimit==dictionary) /* match within extDict */ ) {
1172
0
                const BYTE* limit = ip + (dictEnd-match);
1173
0
                assert(dictEnd > match);
1174
0
                if (limit > matchlimit) limit = matchlimit;
1175
0
                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
1176
0
                ip += (size_t)matchCode + MINMATCH;
1177
0
                if (ip==limit) {
1178
0
                    unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit);
1179
0
                    matchCode += more;
1180
0
                    ip += more;
1181
0
                }
1182
0
                DEBUGLOG(6, "             with matchLength=%u starting in extDict", matchCode+MINMATCH);
1183
0
            } else {
1184
0
                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
1185
0
                ip += (size_t)matchCode + MINMATCH;
1186
0
                DEBUGLOG(6, "             with matchLength=%u", matchCode+MINMATCH);
1187
0
            }
1188
1189
0
            if ((outputDirective) &&    /* Check output buffer overflow */
1190
0
                (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) {
1191
0
                if (outputDirective == fillOutput) {
1192
                    /* Match description too long : reduce it */
1193
0
                    U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255;
1194
0
                    ip -= matchCode - newMatchCode;
1195
0
                    assert(newMatchCode < matchCode);
1196
0
                    matchCode = newMatchCode;
1197
0
                    if (unlikely(ip <= filledIp)) {
1198
                        /* We have already filled up to filledIp so if ip ends up less than filledIp
1199
                         * we have positions in the hash table beyond the current position. This is
1200
                         * a problem if we reuse the hash table. So we have to remove these positions
1201
                         * from the hash table.
1202
                         */
1203
0
                        const BYTE* ptr;
1204
0
                        DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip));
1205
0
                        for (ptr = ip; ptr <= filledIp; ++ptr) {
1206
0
                            U32 const h = LZ4_hashPosition(ptr, tableType);
1207
0
                            LZ4_clearHash(h, cctx->hashTable, tableType);
1208
0
                        }
1209
0
                    }
1210
0
                } else {
1211
0
                    assert(outputDirective == limitedOutput);
1212
0
                    return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
1213
0
                }
1214
0
            }
1215
0
            if (matchCode >= ML_MASK) {
1216
0
                *token += ML_MASK;
1217
0
                matchCode -= ML_MASK;
1218
0
                LZ4_write32(op, 0xFFFFFFFF);
1219
0
                while (matchCode >= 4*255) {
1220
0
                    op+=4;
1221
0
                    LZ4_write32(op, 0xFFFFFFFF);
1222
0
                    matchCode -= 4*255;
1223
0
                }
1224
0
                op += matchCode / 255;
1225
0
                *op++ = (BYTE)(matchCode % 255);
1226
0
            } else
1227
0
                *token += (BYTE)(matchCode);
1228
0
        }
1229
        /* Ensure we have enough space for the last literals. */
1230
0
        assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit));
1231
1232
0
        anchor = ip;
1233
1234
        /* Test end of chunk */
1235
0
        if (ip >= mflimitPlusOne) break;
1236
1237
        /* Fill table */
1238
0
        {   U32 const h = LZ4_hashPosition(ip-2, tableType);
1239
0
            if (tableType == byPtr) {
1240
0
                LZ4_putPositionOnHash(ip-2, h, cctx->hashTable, byPtr);
1241
0
            } else {
1242
0
                U32 const idx = (U32)((ip-2) - base);
1243
0
                LZ4_putIndexOnHash(idx, h, cctx->hashTable, tableType);
1244
0
        }   }
1245
1246
        /* Test next position */
1247
0
        if (tableType == byPtr) {
1248
1249
0
            match = LZ4_getPosition(ip, cctx->hashTable, tableType);
1250
0
            LZ4_putPosition(ip, cctx->hashTable, tableType);
1251
0
            if ( (match+LZ4_DISTANCE_MAX >= ip)
1252
0
              && (LZ4_read32(match) == LZ4_read32(ip)) )
1253
0
            { token=op++; *token=0; goto _next_match; }
1254
1255
0
        } else {   /* byU32, byU16 */
1256
1257
0
            U32 const h = LZ4_hashPosition(ip, tableType);
1258
0
            U32 const current = (U32)(ip-base);
1259
0
            U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
1260
0
            assert(matchIndex < current);
1261
0
            if (dictDirective == usingDictCtx) {
1262
0
                if (matchIndex < startIndex) {
1263
                    /* there was no match, try the dictionary */
1264
0
                    assert(tableType == byU32);
1265
0
                    matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
1266
0
                    match = dictBase + matchIndex;
1267
0
                    lowLimit = dictionary;   /* required for match length counter */
1268
0
                    matchIndex += dictDelta;
1269
0
                } else {
1270
0
                    match = base + matchIndex;
1271
0
                    lowLimit = (const BYTE*)source;  /* required for match length counter */
1272
0
                }
1273
0
            } else if (dictDirective==usingExtDict) {
1274
0
                if (matchIndex < startIndex) {
1275
0
                    assert(dictBase);
1276
0
                    match = dictBase + matchIndex;
1277
0
                    lowLimit = dictionary;   /* required for match length counter */
1278
0
                } else {
1279
0
                    match = base + matchIndex;
1280
0
                    lowLimit = (const BYTE*)source;   /* required for match length counter */
1281
0
                }
1282
0
            } else {   /* single memory segment */
1283
0
                match = base + matchIndex;
1284
0
            }
1285
0
            LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
1286
0
            assert(matchIndex < current);
1287
0
            if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1)
1288
0
              && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current))
1289
0
              && (LZ4_read32(match) == LZ4_read32(ip)) ) {
1290
0
                token=op++;
1291
0
                *token=0;
1292
0
                if (maybe_extMem) offset = current - matchIndex;
1293
0
                DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
1294
0
                            (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source));
1295
0
                goto _next_match;
1296
0
            }
1297
0
        }
1298
1299
        /* Prepare next loop */
1300
0
        forwardH = LZ4_hashPosition(++ip, tableType);
1301
1302
0
    }
1303
1304
0
_last_literals:
1305
    /* Encode Last Literals */
1306
0
    {   size_t lastRun = (size_t)(iend - anchor);
1307
0
        if ( (outputDirective) &&  /* Check output buffer overflow */
1308
0
            (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) {
1309
0
            if (outputDirective == fillOutput) {
1310
                /* adapt lastRun to fill 'dst' */
1311
0
                assert(olimit >= op);
1312
0
                lastRun  = (size_t)(olimit-op) - 1/*token*/;
1313
0
                lastRun -= (lastRun + 256 - RUN_MASK) / 256;  /*additional length tokens*/
1314
0
            } else {
1315
0
                assert(outputDirective == limitedOutput);
1316
0
                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
1317
0
            }
1318
0
        }
1319
0
        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun);
1320
0
        if (lastRun >= RUN_MASK) {
1321
0
            size_t accumulator = lastRun - RUN_MASK;
1322
0
            *op++ = RUN_MASK << ML_BITS;
1323
0
            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
1324
0
            *op++ = (BYTE) accumulator;
1325
0
        } else {
1326
0
            *op++ = (BYTE)(lastRun<<ML_BITS);
1327
0
        }
1328
0
        LZ4_memcpy(op, anchor, lastRun);
1329
0
        ip = anchor + lastRun;
1330
0
        op += lastRun;
1331
0
    }
1332
1333
0
    if (outputDirective == fillOutput) {
1334
0
        *inputConsumed = (int) (((const char*)ip)-source);
1335
0
    }
1336
0
    result = (int)(((char*)op) - dest);
1337
0
    assert(result > 0);
1338
0
    DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result);
1339
0
    return result;
1340
0
}
1341
1342
/** LZ4_compress_generic() :
1343
 *  inlined, to ensure branches are decided at compilation time;
1344
 *  takes care of src == (NULL, 0)
1345
 *  and forward the rest to LZ4_compress_generic_validated */
1346
LZ4_FORCE_INLINE int LZ4_compress_generic(
1347
                 LZ4_stream_t_internal* const cctx,
1348
                 const char* const src,
1349
                 char* const dst,
1350
                 const int srcSize,
1351
                 int *inputConsumed, /* only written when outputDirective == fillOutput */
1352
                 const int dstCapacity,
1353
                 const limitedOutput_directive outputDirective,
1354
                 const tableType_t tableType,
1355
                 const dict_directive dictDirective,
1356
                 const dictIssue_directive dictIssue,
1357
                 const int acceleration)
1358
0
{
1359
0
    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i",
1360
0
                srcSize, dstCapacity);
1361
1362
0
    if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; }  /* Unsupported srcSize, too large (or negative) */
1363
0
    if (srcSize == 0) {   /* src == NULL supported if srcSize == 0 */
1364
0
        if (outputDirective != notLimited && dstCapacity <= 0) return 0;  /* no output, can't write anything */
1365
0
        DEBUGLOG(5, "Generating an empty block");
1366
0
        assert(outputDirective == notLimited || dstCapacity >= 1);
1367
0
        assert(dst != NULL);
1368
0
        dst[0] = 0;
1369
0
        if (outputDirective == fillOutput) {
1370
0
            assert (inputConsumed != NULL);
1371
0
            *inputConsumed = 0;
1372
0
        }
1373
0
        return 1;
1374
0
    }
1375
0
    assert(src != NULL);
1376
1377
0
    return LZ4_compress_generic_validated(cctx, src, dst, srcSize,
1378
0
                inputConsumed, /* only written into if outputDirective == fillOutput */
1379
0
                dstCapacity, outputDirective,
1380
0
                tableType, dictDirective, dictIssue, acceleration);
1381
0
}
1382
1383
1384
int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
1385
0
{
1386
0
    LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
1387
0
    assert(ctx != NULL);
1388
0
    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
1389
0
    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
1390
0
    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
1391
0
        if (inputSize < LZ4_64Klimit) {
1392
0
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
1393
0
        } else {
1394
0
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
1395
0
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
1396
0
        }
1397
0
    } else {
1398
0
        if (inputSize < LZ4_64Klimit) {
1399
0
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
1400
0
        } else {
1401
0
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
1402
0
            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration);
1403
0
        }
1404
0
    }
1405
0
}
1406
1407
/**
1408
 * LZ4_compress_fast_extState_fastReset() :
1409
 * A variant of LZ4_compress_fast_extState().
1410
 *
1411
 * Using this variant avoids an expensive initialization step. It is only safe
1412
 * to call if the state buffer is known to be correctly initialized already
1413
 * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
1414
 * "correctly initialized").
1415
 */
1416
int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
1417
0
{
1418
0
    LZ4_stream_t_internal* const ctx = &((LZ4_stream_t*)state)->internal_donotuse;
1419
0
    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
1420
0
    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
1421
0
    assert(ctx != NULL);
1422
1423
0
    if (dstCapacity >= LZ4_compressBound(srcSize)) {
1424
0
        if (srcSize < LZ4_64Klimit) {
1425
0
            const tableType_t tableType = byU16;
1426
0
            LZ4_prepareTable(ctx, srcSize, tableType);
1427
0
            if (ctx->currentOffset) {
1428
0
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration);
1429
0
            } else {
1430
0
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
1431
0
            }
1432
0
        } else {
1433
0
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
1434
0
            LZ4_prepareTable(ctx, srcSize, tableType);
1435
0
            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
1436
0
        }
1437
0
    } else {
1438
0
        if (srcSize < LZ4_64Klimit) {
1439
0
            const tableType_t tableType = byU16;
1440
0
            LZ4_prepareTable(ctx, srcSize, tableType);
1441
0
            if (ctx->currentOffset) {
1442
0
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration);
1443
0
            } else {
1444
0
                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
1445
0
            }
1446
0
        } else {
1447
0
            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
1448
0
            LZ4_prepareTable(ctx, srcSize, tableType);
1449
0
            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
1450
0
        }
1451
0
    }
1452
0
}
1453
1454
1455
int LZ4_compress_fast(const char* src, char* dest, int srcSize, int dstCapacity, int acceleration)
1456
0
{
1457
0
    int result;
1458
#if (LZ4_HEAPMODE)
1459
    LZ4_stream_t* const ctxPtr = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
1460
    if (ctxPtr == NULL) return 0;
1461
#else
1462
0
    LZ4_stream_t ctx;
1463
0
    LZ4_stream_t* const ctxPtr = &ctx;
1464
0
#endif
1465
0
    result = LZ4_compress_fast_extState(ctxPtr, src, dest, srcSize, dstCapacity, acceleration);
1466
1467
#if (LZ4_HEAPMODE)
1468
    FREEMEM(ctxPtr);
1469
#endif
1470
0
    return result;
1471
0
}
1472
1473
1474
int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity)
1475
0
{
1476
0
    return LZ4_compress_fast(src, dst, srcSize, dstCapacity, 1);
1477
0
}
1478
1479
1480
/* Note!: This function leaves the stream in an unclean/broken state!
1481
 * It is not safe to subsequently use the same state with a _fastReset() or
1482
 * _continue() call without resetting it. */
1483
static int LZ4_compress_destSize_extState_internal(LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration)
1484
0
{
1485
0
    void* const s = LZ4_initStream(state, sizeof (*state));
1486
0
    assert(s != NULL); (void)s;
1487
1488
0
    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
1489
0
        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, acceleration);
1490
0
    } else {
1491
0
        if (*srcSizePtr < LZ4_64Klimit) {
1492
0
            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, acceleration);
1493
0
        } else {
1494
0
            tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
1495
0
            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, acceleration);
1496
0
    }   }
1497
0
}
1498
1499
int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration)
1500
0
{
1501
0
    int const r = LZ4_compress_destSize_extState_internal((LZ4_stream_t*)state, src, dst, srcSizePtr, targetDstSize, acceleration);
1502
    /* clean the state on exit */
1503
0
    LZ4_initStream(state, sizeof (LZ4_stream_t));
1504
0
    return r;
1505
0
}
1506
1507
1508
int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
1509
0
{
1510
#if (LZ4_HEAPMODE)
1511
    LZ4_stream_t* const ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
1512
    if (ctx == NULL) return 0;
1513
#else
1514
0
    LZ4_stream_t ctxBody;
1515
0
    LZ4_stream_t* const ctx = &ctxBody;
1516
0
#endif
1517
1518
0
    int result = LZ4_compress_destSize_extState_internal(ctx, src, dst, srcSizePtr, targetDstSize, 1);
1519
1520
#if (LZ4_HEAPMODE)
1521
    FREEMEM(ctx);
1522
#endif
1523
0
    return result;
1524
0
}
1525
1526
1527
1528
/*-******************************
1529
*  Streaming functions
1530
********************************/
1531
1532
#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
1533
LZ4_stream_t* LZ4_createStream(void)
1534
0
{
1535
0
    LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
1536
0
    LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal));
1537
0
    DEBUGLOG(4, "LZ4_createStream %p", (void*)lz4s);
1538
0
    if (lz4s == NULL) return NULL;
1539
0
    LZ4_initStream(lz4s, sizeof(*lz4s));
1540
0
    return lz4s;
1541
0
}
1542
#endif
1543
1544
static size_t LZ4_stream_t_alignment(void)
1545
0
{
1546
0
#if LZ4_ALIGN_TEST
1547
0
    typedef struct { char c; LZ4_stream_t t; } t_a;
1548
0
    return sizeof(t_a) - sizeof(LZ4_stream_t);
1549
#else
1550
    return 1;  /* effectively disabled */
1551
#endif
1552
0
}
1553
1554
LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
1555
0
{
1556
0
    DEBUGLOG(5, "LZ4_initStream");
1557
0
    if (buffer == NULL) { return NULL; }
1558
0
    if (size < sizeof(LZ4_stream_t)) { return NULL; }
1559
0
    if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL;
1560
0
    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal));
1561
0
    return (LZ4_stream_t*)buffer;
1562
0
}
1563
1564
/* resetStream is now deprecated,
1565
 * prefer initStream() which is more general */
1566
void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
1567
0
{
1568
0
    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", (void*)LZ4_stream);
1569
0
    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal));
1570
0
}
1571
1572
0
void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
1573
0
    LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
1574
0
}
1575
1576
#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
1577
int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
1578
0
{
1579
0
    if (!LZ4_stream) return 0;   /* support free on NULL */
1580
0
    DEBUGLOG(5, "LZ4_freeStream %p", (void*)LZ4_stream);
1581
0
    FREEMEM(LZ4_stream);
1582
0
    return (0);
1583
0
}
1584
#endif
1585
1586
1587
typedef enum { _ld_fast, _ld_slow } LoadDict_mode_e;
1588
0
#define HASH_UNIT sizeof(reg_t)
1589
int LZ4_loadDict_internal(LZ4_stream_t* LZ4_dict,
1590
                    const char* dictionary, int dictSize,
1591
                    LoadDict_mode_e _ld)
1592
0
{
1593
0
    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
1594
0
    const tableType_t tableType = byU32;
1595
0
    const BYTE* p = (const BYTE*)dictionary;
1596
0
    const BYTE* const dictEnd = p + dictSize;
1597
0
    U32 idx32;
1598
1599
0
    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, (void*)dictionary, (void*)LZ4_dict);
1600
1601
    /* It's necessary to reset the context,
1602
     * and not just continue it with prepareTable()
1603
     * to avoid any risk of generating overflowing matchIndex
1604
     * when compressing using this dictionary */
1605
0
    LZ4_resetStream(LZ4_dict);
1606
1607
    /* We always increment the offset by 64 KB, since, if the dict is longer,
1608
     * we truncate it to the last 64k, and if it's shorter, we still want to
1609
     * advance by a whole window length so we can provide the guarantee that
1610
     * there are only valid offsets in the window, which allows an optimization
1611
     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
1612
     * dictionary isn't a full 64k. */
1613
0
    dict->currentOffset += 64 KB;
1614
1615
0
    if (dictSize < (int)HASH_UNIT) {
1616
0
        return 0;
1617
0
    }
1618
1619
0
    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
1620
0
    dict->dictionary = p;
1621
0
    dict->dictSize = (U32)(dictEnd - p);
1622
0
    dict->tableType = (U32)tableType;
1623
0
    idx32 = dict->currentOffset - dict->dictSize;
1624
1625
0
    while (p <= dictEnd-HASH_UNIT) {
1626
0
        U32 const h = LZ4_hashPosition(p, tableType);
1627
        /* Note: overwriting => favors positions end of dictionary */
1628
0
        LZ4_putIndexOnHash(idx32, h, dict->hashTable, tableType);
1629
0
        p+=3; idx32+=3;
1630
0
    }
1631
1632
0
    if (_ld == _ld_slow) {
1633
        /* Fill hash table with additional references, to improve compression capability */
1634
0
        p = dict->dictionary;
1635
0
        idx32 = dict->currentOffset - dict->dictSize;
1636
0
        while (p <= dictEnd-HASH_UNIT) {
1637
0
            U32 const h = LZ4_hashPosition(p, tableType);
1638
0
            U32 const limit = dict->currentOffset - 64 KB;
1639
0
            if (LZ4_getIndexOnHash(h, dict->hashTable, tableType) <= limit) {
1640
                /* Note: not overwriting => favors positions beginning of dictionary */
1641
0
                LZ4_putIndexOnHash(idx32, h, dict->hashTable, tableType);
1642
0
            }
1643
0
            p++; idx32++;
1644
0
        }
1645
0
    }
1646
1647
0
    return (int)dict->dictSize;
1648
0
}
1649
1650
int LZ4_loadDict(LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
1651
0
{
1652
0
    return LZ4_loadDict_internal(LZ4_dict, dictionary, dictSize, _ld_fast);
1653
0
}
1654
1655
int LZ4_loadDictSlow(LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
1656
0
{
1657
0
    return LZ4_loadDict_internal(LZ4_dict, dictionary, dictSize, _ld_slow);
1658
0
}
1659
1660
void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)
1661
0
{
1662
0
    const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :
1663
0
        &(dictionaryStream->internal_donotuse);
1664
1665
0
    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
1666
0
             (void*)workingStream, (void*)dictionaryStream,
1667
0
             dictCtx != NULL ? dictCtx->dictSize : 0);
1668
1669
0
    if (dictCtx != NULL) {
1670
        /* If the current offset is zero, we will never look in the
1671
         * external dictionary context, since there is no value a table
1672
         * entry can take that indicate a miss. In that case, we need
1673
         * to bump the offset to something non-zero.
1674
         */
1675
0
        if (workingStream->internal_donotuse.currentOffset == 0) {
1676
0
            workingStream->internal_donotuse.currentOffset = 64 KB;
1677
0
        }
1678
1679
        /* Don't actually attach an empty dictionary.
1680
         */
1681
0
        if (dictCtx->dictSize == 0) {
1682
0
            dictCtx = NULL;
1683
0
        }
1684
0
    }
1685
0
    workingStream->internal_donotuse.dictCtx = dictCtx;
1686
0
}
1687
1688
1689
static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
1690
0
{
1691
0
    assert(nextSize >= 0);
1692
0
    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
1693
        /* rescale hash table */
1694
0
        U32 const delta = LZ4_dict->currentOffset - 64 KB;
1695
0
        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
1696
0
        int i;
1697
0
        DEBUGLOG(4, "LZ4_renormDictT");
1698
0
        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
1699
0
            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
1700
0
            else LZ4_dict->hashTable[i] -= delta;
1701
0
        }
1702
0
        LZ4_dict->currentOffset = 64 KB;
1703
0
        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
1704
0
        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
1705
0
    }
1706
0
}
1707
1708
1709
int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
1710
                                const char* source, char* dest,
1711
                                int inputSize, int maxOutputSize,
1712
                                int acceleration)
1713
0
{
1714
0
    const tableType_t tableType = byU32;
1715
0
    LZ4_stream_t_internal* const streamPtr = &LZ4_stream->internal_donotuse;
1716
0
    const char* dictEnd = streamPtr->dictSize ? (const char*)streamPtr->dictionary + streamPtr->dictSize : NULL;
1717
1718
0
    DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i, dictSize=%u)", inputSize, streamPtr->dictSize);
1719
1720
0
    LZ4_renormDictT(streamPtr, inputSize);   /* fix index overflow */
1721
0
    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
1722
0
    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
1723
1724
    /* invalidate tiny dictionaries */
1725
0
    if ( (streamPtr->dictSize < 4)     /* tiny dictionary : not enough for a hash */
1726
0
      && (dictEnd != source)           /* prefix mode */
1727
0
      && (inputSize > 0)               /* tolerance : don't lose history, in case next invocation would use prefix mode */
1728
0
      && (streamPtr->dictCtx == NULL)  /* usingDictCtx */
1729
0
      ) {
1730
0
        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, (void*)streamPtr->dictionary);
1731
        /* remove dictionary existence from history, to employ faster prefix mode */
1732
0
        streamPtr->dictSize = 0;
1733
0
        streamPtr->dictionary = (const BYTE*)source;
1734
0
        dictEnd = source;
1735
0
    }
1736
1737
    /* Check overlapping input/dictionary space */
1738
0
    {   const char* const sourceEnd = source + inputSize;
1739
0
        if ((sourceEnd > (const char*)streamPtr->dictionary) && (sourceEnd < dictEnd)) {
1740
0
            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
1741
0
            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
1742
0
            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
1743
0
            streamPtr->dictionary = (const BYTE*)dictEnd - streamPtr->dictSize;
1744
0
        }
1745
0
    }
1746
1747
    /* prefix mode : source data follows dictionary */
1748
0
    if (dictEnd == source) {
1749
0
        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
1750
0
            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration);
1751
0
        else
1752
0
            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration);
1753
0
    }
1754
1755
    /* external dictionary mode */
1756
0
    {   int result;
1757
0
        if (streamPtr->dictCtx) {
1758
            /* We depend here on the fact that dictCtx'es (produced by
1759
             * LZ4_loadDict) guarantee that their tables contain no references
1760
             * to offsets between dictCtx->currentOffset - 64 KB and
1761
             * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe
1762
             * to use noDictIssue even when the dict isn't a full 64 KB.
1763
             */
1764
0
            if (inputSize > 4 KB) {
1765
                /* For compressing large blobs, it is faster to pay the setup
1766
                 * cost to copy the dictionary's tables into the active context,
1767
                 * so that the compression loop is only looking into one table.
1768
                 */
1769
0
                LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr));
1770
0
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
1771
0
            } else {
1772
0
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration);
1773
0
            }
1774
0
        } else {  /* small data <= 4 KB */
1775
0
            if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
1776
0
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration);
1777
0
            } else {
1778
0
                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
1779
0
            }
1780
0
        }
1781
0
        streamPtr->dictionary = (const BYTE*)source;
1782
0
        streamPtr->dictSize = (U32)inputSize;
1783
0
        return result;
1784
0
    }
1785
0
}
1786
1787
1788
/* Hidden debug function, to force-test external dictionary mode */
1789
int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
1790
0
{
1791
0
    LZ4_stream_t_internal* const streamPtr = &LZ4_dict->internal_donotuse;
1792
0
    int result;
1793
1794
0
    LZ4_renormDictT(streamPtr, srcSize);
1795
1796
0
    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
1797
0
        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
1798
0
    } else {
1799
0
        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
1800
0
    }
1801
1802
0
    streamPtr->dictionary = (const BYTE*)source;
1803
0
    streamPtr->dictSize = (U32)srcSize;
1804
1805
0
    return result;
1806
0
}
1807
1808
1809
/*! LZ4_saveDict() :
1810
 *  If previously compressed data block is not guaranteed to remain available at its memory location,
1811
 *  save it into a safer place (char* safeBuffer).
1812
 *  Note : no need to call LZ4_loadDict() afterwards, dictionary is immediately usable,
1813
 *         one can therefore call LZ4_compress_fast_continue() right after.
1814
 * @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
1815
 */
1816
int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
1817
0
{
1818
0
    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
1819
1820
0
    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, (void*)safeBuffer);
1821
1822
0
    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
1823
0
    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }
1824
1825
0
    if (safeBuffer == NULL) assert(dictSize == 0);
1826
0
    if (dictSize > 0) {
1827
0
        const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
1828
0
        assert(dict->dictionary);
1829
0
        LZ4_memmove(safeBuffer, previousDictEnd - dictSize, (size_t)dictSize);
1830
0
    }
1831
1832
0
    dict->dictionary = (const BYTE*)safeBuffer;
1833
0
    dict->dictSize = (U32)dictSize;
1834
1835
0
    return dictSize;
1836
0
}
1837
1838
1839
1840
/*-*******************************
1841
 *  Decompression functions
1842
 ********************************/
1843
1844
typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;
1845
1846
#undef MIN
1847
8.08k
#define MIN(a,b)    ( (a) < (b) ? (a) : (b) )
1848
1849
1850
/* variant for decompress_unsafe()
1851
 * does not know end of input
1852
 * presumes input is well formed
1853
 * note : will consume at least one byte */
1854
static size_t read_long_length_no_check(const BYTE** pp)
1855
0
{
1856
0
    size_t b, l = 0;
1857
0
    do { b = **pp; (*pp)++; l += b; } while (b==255);
1858
0
    DEBUGLOG(6, "read_long_length_no_check: +length=%zu using %zu input bytes", l, l/255 + 1)
1859
0
    return l;
1860
0
}
1861
1862
/* core decoder variant for LZ4_decompress_fast*()
1863
 * for legacy support only : these entry points are deprecated.
1864
 * - Presumes input is correctly formed (no defense vs malformed inputs)
1865
 * - Does not know input size (presume input buffer is "large enough")
1866
 * - Decompress a full block (only)
1867
 * @return : nb of bytes read from input.
1868
 * Note : this variant is not optimized for speed, just for maintenance.
1869
 *        the goal is to remove support of decompress_fast*() variants by v2.0
1870
**/
1871
LZ4_FORCE_INLINE int
1872
LZ4_decompress_unsafe_generic(
1873
                 const BYTE* const istart,
1874
                 BYTE* const ostart,
1875
                 int decompressedSize,
1876
1877
                 size_t prefixSize,
1878
                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
1879
                 const size_t dictSize         /* note: =0 if dictStart==NULL */
1880
                 )
1881
0
{
1882
0
    const BYTE* ip = istart;
1883
0
    BYTE* op = (BYTE*)ostart;
1884
0
    BYTE* const oend = ostart + decompressedSize;
1885
0
    const BYTE* const prefixStart = ostart - prefixSize;
1886
1887
0
    DEBUGLOG(5, "LZ4_decompress_unsafe_generic");
1888
0
    if (dictStart == NULL) assert(dictSize == 0);
1889
1890
0
    while (1) {
1891
        /* start new sequence */
1892
0
        unsigned token = *ip++;
1893
1894
        /* literals */
1895
0
        {   size_t ll = token >> ML_BITS;
1896
0
            if (ll==15) {
1897
                /* long literal length */
1898
0
                ll += read_long_length_no_check(&ip);
1899
0
            }
1900
0
            if ((size_t)(oend-op) < ll) return -1; /* output buffer overflow */
1901
0
            LZ4_memmove(op, ip, ll); /* support in-place decompression */
1902
0
            op += ll;
1903
0
            ip += ll;
1904
0
            if ((size_t)(oend-op) < MFLIMIT) {
1905
0
                if (op==oend) break;  /* end of block */
1906
0
                DEBUGLOG(5, "invalid: literals end at distance %zi from end of block", oend-op);
1907
                /* incorrect end of block :
1908
                 * last match must start at least MFLIMIT==12 bytes before end of output block */
1909
0
                return -1;
1910
0
        }   }
1911
1912
        /* match */
1913
0
        {   size_t ml = token & 15;
1914
0
            size_t const offset = LZ4_readLE16(ip);
1915
0
            ip+=2;
1916
1917
0
            if (ml==15) {
1918
                /* long literal length */
1919
0
                ml += read_long_length_no_check(&ip);
1920
0
            }
1921
0
            ml += MINMATCH;
1922
1923
0
            if ((size_t)(oend-op) < ml) return -1; /* output buffer overflow */
1924
1925
0
            {   const BYTE* match = op - offset;
1926
1927
                /* out of range */
1928
0
                if (offset > (size_t)(op - prefixStart) + dictSize) {
1929
0
                    DEBUGLOG(6, "offset out of range");
1930
0
                    return -1;
1931
0
                }
1932
1933
                /* check special case : extDict */
1934
0
                if (offset > (size_t)(op - prefixStart)) {
1935
                    /* extDict scenario */
1936
0
                    const BYTE* const dictEnd = dictStart + dictSize;
1937
0
                    const BYTE* extMatch = dictEnd - (offset - (size_t)(op-prefixStart));
1938
0
                    size_t const extml = (size_t)(dictEnd - extMatch);
1939
0
                    if (extml > ml) {
1940
                        /* match entirely within extDict */
1941
0
                        LZ4_memmove(op, extMatch, ml);
1942
0
                        op += ml;
1943
0
                        ml = 0;
1944
0
                    } else {
1945
                        /* match split between extDict & prefix */
1946
0
                        LZ4_memmove(op, extMatch, extml);
1947
0
                        op += extml;
1948
0
                        ml -= extml;
1949
0
                    }
1950
0
                    match = prefixStart;
1951
0
                }
1952
1953
                /* match copy - slow variant, supporting overlap copy */
1954
0
                {   size_t u;
1955
0
                    for (u=0; u<ml; u++) {
1956
0
                        op[u] = match[u];
1957
0
            }   }   }
1958
0
            op += ml;
1959
0
            if ((size_t)(oend-op) < LASTLITERALS) {
1960
0
                DEBUGLOG(5, "invalid: match ends at distance %zi from end of block", oend-op);
1961
                /* incorrect end of block :
1962
                 * last match must stop at least LASTLITERALS==5 bytes before end of output block */
1963
0
                return -1;
1964
0
            }
1965
0
        } /* match */
1966
0
    } /* main loop */
1967
0
    return (int)(ip - istart);
1968
0
}
1969
1970
1971
/* Read the variable-length literal or match length.
1972
 *
1973
 * @ip : input pointer
1974
 * @ilimit : position after which if length is not decoded, the input is necessarily corrupted.
1975
 * @initial_check - check ip >= ipmax before start of loop.  Returns initial_error if so.
1976
 * @error (output) - error code.  Must be set to 0 before call.
1977
**/
1978
typedef size_t Rvl_t;
1979
static const Rvl_t rvl_error = (Rvl_t)(-1);
1980
LZ4_FORCE_INLINE Rvl_t
1981
read_variable_length(const BYTE** ip, const BYTE* ilimit,
1982
                     int initial_check)
1983
13.0k
{
1984
13.0k
    Rvl_t s, length = 0;
1985
13.0k
    assert(ip != NULL);
1986
13.0k
    assert(*ip !=  NULL);
1987
13.0k
    assert(ilimit != NULL);
1988
13.0k
    if (initial_check && unlikely((*ip) >= ilimit)) {    /* read limit reached */
1989
760
        return rvl_error;
1990
760
    }
1991
12.3k
    s = **ip;
1992
12.3k
    (*ip)++;
1993
12.3k
    length += s;
1994
12.3k
    if (unlikely((*ip) > ilimit)) {    /* read limit reached */
1995
74
        return rvl_error;
1996
74
    }
1997
    /* accumulator overflow detection (32-bit mode only) */
1998
12.2k
    if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) {
1999
0
        return rvl_error;
2000
0
    }
2001
12.2k
    if (likely(s != 255)) return length;
2002
208M
    do {
2003
208M
        s = **ip;
2004
208M
        (*ip)++;
2005
208M
        length += s;
2006
208M
        if (unlikely((*ip) > ilimit)) {    /* read limit reached */
2007
459
            return rvl_error;
2008
459
        }
2009
        /* accumulator overflow detection (32-bit mode only) */
2010
208M
        if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) {
2011
0
            return rvl_error;
2012
0
        }
2013
208M
    } while (s == 255);
2014
2015
3.82k
    return length;
2016
4.28k
}
2017
2018
/*! LZ4_decompress_generic() :
2019
 *  This generic decompression function covers all use cases.
2020
 *  It shall be instantiated several times, using different sets of directives.
2021
 *  Note that it is important for performance that this function really get inlined,
2022
 *  in order to remove useless branches during compilation optimization.
2023
 */
2024
LZ4_FORCE_INLINE int
2025
LZ4_decompress_generic(
2026
                 const char* const src,
2027
                 char* const dst,
2028
                 int srcSize,
2029
                 int outputSize,         /* If endOnInput==endOnInputSize, this value is `dstCapacity` */
2030
2031
                 earlyEnd_directive partialDecoding,  /* full, partial */
2032
                 dict_directive dict,                 /* noDict, withPrefix64k, usingExtDict */
2033
                 const BYTE* const lowPrefix,  /* always <= dst, == dst when no prefix */
2034
                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
2035
                 const size_t dictSize         /* note : = 0 if noDict */
2036
                 )
2037
11.4k
{
2038
11.4k
    if ((src == NULL) || (outputSize < 0)) { return -1; }
2039
2040
11.4k
    {   const BYTE* ip = (const BYTE*) src;
2041
11.4k
        const BYTE* const iend = ip + srcSize;
2042
2043
11.4k
        BYTE* op = (BYTE*) dst;
2044
11.4k
        BYTE* const oend = op + outputSize;
2045
11.4k
        BYTE* cpy;
2046
2047
11.4k
        const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize;
2048
2049
11.4k
        const int checkOffset = (dictSize < (int)(64 KB));
2050
2051
2052
        /* Set up the "end" pointers for the shortcut. */
2053
11.4k
        const BYTE* const shortiend = iend - 14 /*maxLL*/ - 2 /*offset*/;
2054
11.4k
        const BYTE* const shortoend = oend - 14 /*maxLL*/ - 18 /*maxML*/;
2055
2056
11.4k
        const BYTE* match;
2057
11.4k
        size_t offset;
2058
11.4k
        unsigned token;
2059
11.4k
        size_t length;
2060
2061
2062
11.4k
        DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize);
2063
2064
        /* Special cases */
2065
11.4k
        assert(lowPrefix <= op);
2066
11.4k
        if (unlikely(outputSize==0)) {
2067
            /* Empty output buffer */
2068
407
            if (partialDecoding) return 0;
2069
185
            return ((srcSize==1) && (*ip==0)) ? 0 : -1;
2070
407
        }
2071
11.0k
        if (unlikely(srcSize==0)) { return -1; }
2072
2073
    /* LZ4_FAST_DEC_LOOP:
2074
     * designed for modern OoO performance cpus,
2075
     * where copying reliably 32-bytes is preferable to an unpredictable branch.
2076
     * note : fast loop may show a regression for some client arm chips. */
2077
11.0k
#if LZ4_FAST_DEC_LOOP
2078
11.0k
        if ((oend - op) < FASTLOOP_SAFE_DISTANCE) {
2079
5.02k
            DEBUGLOG(6, "move to safe decode loop");
2080
5.02k
            goto safe_decode;
2081
5.02k
        }
2082
2083
        /* Fast loop : decode sequences as long as output < oend-FASTLOOP_SAFE_DISTANCE */
2084
6.03k
        DEBUGLOG(6, "using fast decode loop");
2085
18.5k
        while (1) {
2086
            /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */
2087
18.5k
            assert(oend - op >= FASTLOOP_SAFE_DISTANCE);
2088
18.5k
            assert(ip < iend);
2089
18.5k
            token = *ip++;
2090
18.5k
            length = token >> ML_BITS;  /* literal length */
2091
18.5k
            DEBUGLOG(7, "blockPos%6u: litLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
2092
2093
            /* decode literal length */
2094
18.5k
            if (length == RUN_MASK) {
2095
3.85k
                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
2096
3.85k
                if (addl == rvl_error) {
2097
279
                    DEBUGLOG(6, "error reading long literal length");
2098
279
                    goto _output_error;
2099
279
                }
2100
3.57k
                length += addl;
2101
3.57k
                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
2102
3.57k
                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
2103
2104
                /* copy literals */
2105
3.57k
                LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
2106
3.57k
                if ((op+length>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; }
2107
1.96k
                LZ4_wildCopy32(op, ip, op+length);
2108
1.96k
                ip += length; op += length;
2109
14.7k
            } else if (ip <= iend-(16 + 1/*max lit + offset + nextToken*/)) {
2110
                /* We don't need to check oend, since we check it once for each loop below */
2111
13.7k
                DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length);
2112
                /* Literals can only be <= 14, but hope compilers optimize better when copy by a register size */
2113
13.7k
                LZ4_memcpy(op, ip, 16);
2114
13.7k
                ip += length; op += length;
2115
13.7k
            } else {
2116
981
                goto safe_literal_copy;
2117
981
            }
2118
2119
            /* get offset */
2120
15.7k
            offset = LZ4_readLE16(ip); ip+=2;
2121
15.7k
            DEBUGLOG(6, "blockPos%6u: offset = %u", (unsigned)(op-(BYTE*)dst), (unsigned)offset);
2122
15.7k
            match = op - offset;
2123
15.7k
            assert(match <= op);  /* overflow check */
2124
2125
            /* get matchlength */
2126
15.7k
            length = token & ML_MASK;
2127
15.7k
            DEBUGLOG(7, "  match length token = %u (len==%u)", (unsigned)length, (unsigned)length+MINMATCH);
2128
2129
15.7k
            if (length == ML_MASK) {
2130
4.48k
                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
2131
4.48k
                if (addl == rvl_error) {
2132
74
                    DEBUGLOG(5, "error reading long match length");
2133
74
                    goto _output_error;
2134
74
                }
2135
4.41k
                length += addl;
2136
4.41k
                length += MINMATCH;
2137
4.41k
                DEBUGLOG(7, "  long match length == %u", (unsigned)length);
2138
4.41k
                if (unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */
2139
4.41k
                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
2140
1.84k
                    goto safe_match_copy;
2141
1.84k
                }
2142
11.2k
            } else {
2143
11.2k
                length += MINMATCH;
2144
11.2k
                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
2145
663
                    DEBUGLOG(7, "moving to safe_match_copy (ml==%u)", (unsigned)length);
2146
663
                    goto safe_match_copy;
2147
663
                }
2148
2149
                /* Fastpath check: skip LZ4_wildCopy32 when true */
2150
10.5k
                if ((dict == withPrefix64k) || (match >= lowPrefix)) {
2151
8.51k
                    if (offset >= 8) {
2152
1.24k
                        assert(match >= lowPrefix);
2153
1.24k
                        assert(match <= op);
2154
1.24k
                        assert(op + 18 <= oend);
2155
2156
1.24k
                        LZ4_memcpy(op, match, 8);
2157
1.24k
                        LZ4_memcpy(op+8, match+8, 8);
2158
1.24k
                        LZ4_memcpy(op+16, match+16, 2);
2159
1.24k
                        op += length;
2160
1.24k
                        continue;
2161
1.24k
            }   }   }
2162
2163
11.8k
            if ( checkOffset && (unlikely(match + dictSize < lowPrefix)) ) {
2164
582
                DEBUGLOG(5, "Error : pos=%zi, offset=%zi => outside buffers", op-lowPrefix, op-match);
2165
582
                goto _output_error;
2166
582
            }
2167
            /* match starting within external dictionary */
2168
11.3k
            if ((dict==usingExtDict) && (match < lowPrefix)) {
2169
1.75k
                assert(dictEnd != NULL);
2170
1.75k
                if (unlikely(op+length > oend-LASTLITERALS)) {
2171
0
                    if (partialDecoding) {
2172
0
                        DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd");
2173
0
                        length = MIN(length, (size_t)(oend-op));
2174
0
                    } else {
2175
0
                        DEBUGLOG(6, "end-of-block condition violated")
2176
0
                        goto _output_error;
2177
0
                }   }
2178
2179
1.75k
                if (length <= (size_t)(lowPrefix-match)) {
2180
                    /* match fits entirely within external dictionary : just copy */
2181
1.40k
                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
2182
1.40k
                    op += length;
2183
1.40k
                } else {
2184
                    /* match stretches into both external dictionary and current block */
2185
352
                    size_t const copySize = (size_t)(lowPrefix - match);
2186
352
                    size_t const restSize = length - copySize;
2187
352
                    LZ4_memcpy(op, dictEnd - copySize, copySize);
2188
352
                    op += copySize;
2189
352
                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
2190
200
                        BYTE* const endOfMatch = op + restSize;
2191
200
                        const BYTE* copyFrom = lowPrefix;
2192
6.15k
                        while (op < endOfMatch) { *op++ = *copyFrom++; }
2193
200
                    } else {
2194
152
                        LZ4_memcpy(op, lowPrefix, restSize);
2195
152
                        op += restSize;
2196
152
                }   }
2197
1.75k
                continue;
2198
1.75k
            }
2199
2200
            /* copy match within block */
2201
9.55k
            cpy = op + length;
2202
2203
9.55k
            assert((op <= oend) && (oend-op >= 32));
2204
9.55k
            if (unlikely(offset<16)) {
2205
9.04k
                LZ4_memcpy_using_offset(op, match, cpy, offset);
2206
9.04k
            } else {
2207
512
                LZ4_wildCopy32(op, match, cpy);
2208
512
            }
2209
2210
9.55k
            op = cpy;   /* wildcopy correction */
2211
9.55k
        }
2212
5.02k
    safe_decode:
2213
5.02k
#endif
2214
2215
        /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */
2216
5.02k
        DEBUGLOG(6, "using safe decode loop");
2217
14.8k
        while (1) {
2218
14.8k
            assert(ip < iend);
2219
14.8k
            token = *ip++;
2220
14.8k
            length = token >> ML_BITS;  /* literal length */
2221
14.8k
            DEBUGLOG(7, "blockPos%6u: litLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
2222
2223
            /* A two-stage shortcut for the most common case:
2224
             * 1) If the literal length is 0..14, and there is enough space,
2225
             * enter the shortcut and copy 16 bytes on behalf of the literals
2226
             * (in the fast mode, only 8 bytes can be safely copied this way).
2227
             * 2) Further if the match length is 4..18, copy 18 bytes in a similar
2228
             * manner; but we ensure that there's enough space in the output for
2229
             * those 18 bytes earlier, upon entering the shortcut (in other words,
2230
             * there is a combined check for both stages).
2231
             */
2232
14.8k
            if ( (length != RUN_MASK)
2233
                /* strictly "less than" on input, to re-enter the loop with at least one byte */
2234
14.8k
              && likely((ip < shortiend) & (op <= shortoend)) ) {
2235
                /* Copy the literals */
2236
3.34k
                LZ4_memcpy(op, ip, 16);
2237
3.34k
                op += length; ip += length;
2238
2239
                /* The second stage: prepare for match copying, decode full info.
2240
                 * If it doesn't work out, the info won't be wasted. */
2241
3.34k
                length = token & ML_MASK; /* match length */
2242
3.34k
                DEBUGLOG(7, "blockPos%6u: matchLength token = %u (len=%u)", (unsigned)(op-(BYTE*)dst), (unsigned)length, (unsigned)length + 4);
2243
3.34k
                offset = LZ4_readLE16(ip); ip += 2;
2244
3.34k
                match = op - offset;
2245
3.34k
                assert(match <= op); /* check overflow */
2246
2247
                /* Do not deal with overlapping matches. */
2248
3.34k
                if ( (length != ML_MASK)
2249
3.34k
                  && (offset >= 8)
2250
3.34k
                  && (dict==withPrefix64k || match >= lowPrefix) ) {
2251
                    /* Copy the match. */
2252
453
                    LZ4_memcpy(op + 0, match + 0, 8);
2253
453
                    LZ4_memcpy(op + 8, match + 8, 8);
2254
453
                    LZ4_memcpy(op +16, match +16, 2);
2255
453
                    op += length + MINMATCH;
2256
                    /* Both stages worked, load the next token. */
2257
453
                    continue;
2258
453
                }
2259
2260
                /* The second stage didn't work out, but the info is ready.
2261
                 * Propel it right to the point of match copying. */
2262
2.89k
                goto _copy_match;
2263
3.34k
            }
2264
2265
            /* decode literal length */
2266
11.4k
            if (length == RUN_MASK) {
2267
2.38k
                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
2268
2.38k
                if (addl == rvl_error) { goto _output_error; }
2269
1.64k
                length += addl;
2270
1.64k
                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
2271
1.64k
                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
2272
1.64k
            }
2273
2274
10.7k
#if LZ4_FAST_DEC_LOOP
2275
13.3k
        safe_literal_copy:
2276
13.3k
#endif
2277
            /* copy literals */
2278
13.3k
            cpy = op+length;
2279
2280
13.3k
            LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
2281
13.3k
            if ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) {
2282
                /* We've either hit the input parsing restriction or the output parsing restriction.
2283
                 * In the normal scenario, decoding a full block, it must be the last sequence,
2284
                 * otherwise it's an error (invalid input or dimensions).
2285
                 * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow.
2286
                 */
2287
7.44k
                if (partialDecoding) {
2288
                    /* Since we are partial decoding we may be in this block because of the output parsing
2289
                     * restriction, which is not valid since the output buffer is allowed to be undersized.
2290
                     */
2291
4.59k
                    DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end")
2292
4.59k
                    DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length);
2293
4.59k
                    DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op));
2294
4.59k
                    DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip));
2295
                    /* Finishing in the middle of a literals segment,
2296
                     * due to lack of input.
2297
                     */
2298
4.59k
                    if (ip+length > iend) {
2299
1.73k
                        length = (size_t)(iend-ip);
2300
1.73k
                        cpy = op + length;
2301
1.73k
                    }
2302
                    /* Finishing in the middle of a literals segment,
2303
                     * due to lack of output space.
2304
                     */
2305
4.59k
                    if (cpy > oend) {
2306
1.07k
                        cpy = oend;
2307
1.07k
                        assert(op<=oend);
2308
1.07k
                        length = (size_t)(oend-op);
2309
1.07k
                    }
2310
4.59k
                } else {
2311
                     /* We must be on the last sequence (or invalid) because of the parsing limitations
2312
                      * so check that we exactly consume the input and don't overrun the output buffer.
2313
                      */
2314
2.84k
                    if ((ip+length != iend) || (cpy > oend)) {
2315
2.79k
                        DEBUGLOG(5, "should have been last run of literals")
2316
2.79k
                        DEBUGLOG(5, "ip(%p) + length(%i) = %p != iend (%p)", (void*)ip, (int)length, (void*)(ip+length), (void*)iend);
2317
2.79k
                        DEBUGLOG(5, "or cpy(%p) > (oend-MFLIMIT)(%p)", (void*)cpy, (void*)(oend-MFLIMIT));
2318
2.79k
                        DEBUGLOG(5, "after writing %u bytes / %i bytes available", (unsigned)(op-(BYTE*)dst), outputSize);
2319
2.79k
                        goto _output_error;
2320
2.79k
                    }
2321
2.84k
                }
2322
4.64k
                LZ4_memmove(op, ip, length);  /* supports overlapping memory regions, for in-place decompression scenarios */
2323
4.64k
                ip += length;
2324
4.64k
                op += length;
2325
                /* Necessarily EOF when !partialDecoding.
2326
                 * When partialDecoding, it is EOF if we've either
2327
                 * filled the output buffer or
2328
                 * can't proceed with reading an offset for following match.
2329
                 */
2330
4.64k
                if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) {
2331
2.72k
                    break;
2332
2.72k
                }
2333
5.89k
            } else {
2334
5.89k
                LZ4_wildCopy8(op, ip, cpy);   /* can overwrite up to 8 bytes beyond cpy */
2335
5.89k
                ip += length; op = cpy;
2336
5.89k
            }
2337
2338
            /* get offset */
2339
7.81k
            offset = LZ4_readLE16(ip); ip+=2;
2340
7.81k
            match = op - offset;
2341
2342
            /* get matchlength */
2343
7.81k
            length = token & ML_MASK;
2344
7.81k
            DEBUGLOG(7, "blockPos%6u: matchLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
2345
2346
10.7k
    _copy_match:
2347
10.7k
            if (length == ML_MASK) {
2348
2.35k
                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
2349
2.35k
                if (addl == rvl_error) { goto _output_error; }
2350
2.14k
                length += addl;
2351
2.14k
                if (unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
2352
2.14k
            }
2353
10.5k
            length += MINMATCH;
2354
2355
10.5k
#if LZ4_FAST_DEC_LOOP
2356
13.0k
        safe_match_copy:
2357
13.0k
#endif
2358
13.0k
            if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
2359
            /* match starting within external dictionary */
2360
10.7k
            if ((dict==usingExtDict) && (match < lowPrefix)) {
2361
3.73k
                assert(dictEnd != NULL);
2362
3.73k
                if (unlikely(op+length > oend-LASTLITERALS)) {
2363
1.06k
                    if (partialDecoding) length = MIN(length, (size_t)(oend-op));
2364
378
                    else goto _output_error;   /* doesn't respect parsing restriction */
2365
1.06k
                }
2366
2367
3.35k
                if (length <= (size_t)(lowPrefix-match)) {
2368
                    /* match fits entirely within external dictionary : just copy */
2369
2.54k
                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
2370
2.54k
                    op += length;
2371
2.54k
                } else {
2372
                    /* match stretches into both external dictionary and current block */
2373
812
                    size_t const copySize = (size_t)(lowPrefix - match);
2374
812
                    size_t const restSize = length - copySize;
2375
812
                    LZ4_memcpy(op, dictEnd - copySize, copySize);
2376
812
                    op += copySize;
2377
812
                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
2378
444
                        BYTE* const endOfMatch = op + restSize;
2379
444
                        const BYTE* copyFrom = lowPrefix;
2380
16.7k
                        while (op < endOfMatch) *op++ = *copyFrom++;
2381
444
                    } else {
2382
368
                        LZ4_memcpy(op, lowPrefix, restSize);
2383
368
                        op += restSize;
2384
368
                }   }
2385
3.35k
                continue;
2386
3.73k
            }
2387
6.97k
            assert(match >= lowPrefix);
2388
2389
            /* copy match within block */
2390
6.97k
            cpy = op + length;
2391
2392
            /* partialDecoding : may end anywhere within the block */
2393
6.97k
            assert(op<=oend);
2394
6.97k
            if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
2395
1.13k
                size_t const mlen = MIN(length, (size_t)(oend-op));
2396
1.13k
                const BYTE* const matchEnd = match + mlen;
2397
1.13k
                BYTE* const copyEnd = op + mlen;
2398
1.13k
                if (matchEnd > op) {   /* overlap copy */
2399
45.1k
                    while (op < copyEnd) { *op++ = *match++; }
2400
1.00k
                } else {
2401
132
                    LZ4_memcpy(op, match, mlen);
2402
132
                }
2403
1.13k
                op = copyEnd;
2404
1.13k
                if (op == oend) { break; }
2405
486
                continue;
2406
1.13k
            }
2407
2408
5.83k
            if (unlikely(offset<8)) {
2409
4.95k
                LZ4_write32(op, 0);   /* silence msan warning when offset==0 */
2410
4.95k
                op[0] = match[0];
2411
4.95k
                op[1] = match[1];
2412
4.95k
                op[2] = match[2];
2413
4.95k
                op[3] = match[3];
2414
4.95k
                match += inc32table[offset];
2415
4.95k
                LZ4_memcpy(op+4, match, 4);
2416
4.95k
                match -= dec64table[offset];
2417
4.95k
            } else {
2418
879
                LZ4_memcpy(op, match, 8);
2419
879
                match += 8;
2420
879
            }
2421
5.83k
            op += 8;
2422
2423
5.83k
            if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
2424
492
                BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1);
2425
492
                if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
2426
163
                if (op < oCopyLimit) {
2427
89
                    LZ4_wildCopy8(op, match, oCopyLimit);
2428
89
                    match += oCopyLimit - op;
2429
89
                    op = oCopyLimit;
2430
89
                }
2431
243
                while (op < cpy) { *op++ = *match++; }
2432
5.34k
            } else {
2433
5.34k
                LZ4_memcpy(op, match, 8);
2434
5.34k
                if (length > 16) { LZ4_wildCopy8(op+8, match+8, cpy); }
2435
5.34k
            }
2436
5.50k
            op = cpy;   /* wildcopy correction */
2437
5.50k
        }
2438
2439
        /* end of decoding */
2440
3.37k
        DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst));
2441
3.37k
        return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
2442
2443
        /* Overflow error detected */
2444
7.68k
    _output_error:
2445
7.68k
        return (int) (-(((const char*)ip)-src))-1;
2446
5.02k
    }
2447
5.02k
}
2448
2449
2450
/*===== Instantiate the API decoding functions. =====*/
2451
2452
LZ4_FORCE_O2
2453
int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
2454
1.04k
{
2455
1.04k
    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
2456
1.04k
                                  decode_full_block, noDict,
2457
1.04k
                                  (BYTE*)dest, NULL, 0);
2458
1.04k
}
2459
2460
LZ4_FORCE_O2
2461
int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity)
2462
2.08k
{
2463
2.08k
    dstCapacity = MIN(targetOutputSize, dstCapacity);
2464
2.08k
    return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,
2465
2.08k
                                  partial_decode,
2466
2.08k
                                  noDict, (BYTE*)dst, NULL, 0);
2467
2.08k
}
2468
2469
LZ4_FORCE_O2
2470
int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
2471
0
{
2472
0
    DEBUGLOG(5, "LZ4_decompress_fast");
2473
0
    return LZ4_decompress_unsafe_generic(
2474
0
                (const BYTE*)source, (BYTE*)dest, originalSize,
2475
0
                0, NULL, 0);
2476
0
}
2477
2478
/*===== Instantiate a few more decoding cases, used more than once. =====*/
2479
2480
LZ4_FORCE_O2 /* Exported, an obsolete API function. */
2481
int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
2482
0
{
2483
0
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
2484
0
                                  decode_full_block, withPrefix64k,
2485
0
                                  (BYTE*)dest - 64 KB, NULL, 0);
2486
0
}
2487
2488
LZ4_FORCE_O2
2489
static int LZ4_decompress_safe_partial_withPrefix64k(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity)
2490
0
{
2491
0
    dstCapacity = MIN(targetOutputSize, dstCapacity);
2492
0
    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
2493
0
                                  partial_decode, withPrefix64k,
2494
0
                                  (BYTE*)dest - 64 KB, NULL, 0);
2495
0
}
2496
2497
/* Another obsolete API function, paired with the previous one. */
2498
int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
2499
0
{
2500
0
    return LZ4_decompress_unsafe_generic(
2501
0
                (const BYTE*)source, (BYTE*)dest, originalSize,
2502
0
                64 KB, NULL, 0);
2503
0
}
2504
2505
LZ4_FORCE_O2
2506
static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize,
2507
                                               size_t prefixSize)
2508
0
{
2509
0
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
2510
0
                                  decode_full_block, noDict,
2511
0
                                  (BYTE*)dest-prefixSize, NULL, 0);
2512
0
}
2513
2514
LZ4_FORCE_O2
2515
static int LZ4_decompress_safe_partial_withSmallPrefix(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity,
2516
                                               size_t prefixSize)
2517
0
{
2518
0
    dstCapacity = MIN(targetOutputSize, dstCapacity);
2519
0
    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
2520
0
                                  partial_decode, noDict,
2521
0
                                  (BYTE*)dest-prefixSize, NULL, 0);
2522
0
}
2523
2524
LZ4_FORCE_O2
2525
int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
2526
                                     int compressedSize, int maxOutputSize,
2527
                                     const void* dictStart, size_t dictSize)
2528
4.17k
{
2529
4.17k
    DEBUGLOG(5, "LZ4_decompress_safe_forceExtDict");
2530
4.17k
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
2531
4.17k
                                  decode_full_block, usingExtDict,
2532
4.17k
                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
2533
4.17k
}
2534
2535
LZ4_FORCE_O2
2536
int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
2537
                                     int compressedSize, int targetOutputSize, int dstCapacity,
2538
                                     const void* dictStart, size_t dictSize)
2539
4.17k
{
2540
4.17k
    dstCapacity = MIN(targetOutputSize, dstCapacity);
2541
4.17k
    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
2542
4.17k
                                  partial_decode, usingExtDict,
2543
4.17k
                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
2544
4.17k
}
2545
2546
LZ4_FORCE_O2
2547
static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize,
2548
                                       const void* dictStart, size_t dictSize)
2549
0
{
2550
0
    return LZ4_decompress_unsafe_generic(
2551
0
                (const BYTE*)source, (BYTE*)dest, originalSize,
2552
0
                0, (const BYTE*)dictStart, dictSize);
2553
0
}
2554
2555
/* The "double dictionary" mode, for use with e.g. ring buffers: the first part
2556
 * of the dictionary is passed as prefix, and the second via dictStart + dictSize.
2557
 * These routines are used only once, in LZ4_decompress_*_continue().
2558
 */
2559
LZ4_FORCE_INLINE
2560
int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize,
2561
                                   size_t prefixSize, const void* dictStart, size_t dictSize)
2562
0
{
2563
0
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
2564
0
                                  decode_full_block, usingExtDict,
2565
0
                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
2566
0
}
2567
2568
/*===== streaming decompression functions =====*/
2569
2570
#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
2571
LZ4_streamDecode_t* LZ4_createStreamDecode(void)
2572
0
{
2573
0
    LZ4_STATIC_ASSERT(sizeof(LZ4_streamDecode_t) >= sizeof(LZ4_streamDecode_t_internal));
2574
0
    return (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
2575
0
}
2576
2577
int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
2578
0
{
2579
0
    if (LZ4_stream == NULL) { return 0; }  /* support free on NULL */
2580
0
    FREEMEM(LZ4_stream);
2581
0
    return 0;
2582
0
}
2583
#endif
2584
2585
/*! LZ4_setStreamDecode() :
2586
 *  Use this function to instruct where to find the dictionary.
2587
 *  This function is not necessary if previous data is still available where it was decoded.
2588
 *  Loading a size of 0 is allowed (same effect as no dictionary).
2589
 * @return : 1 if OK, 0 if error
2590
 */
2591
int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
2592
0
{
2593
0
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
2594
0
    lz4sd->prefixSize = (size_t)dictSize;
2595
0
    if (dictSize) {
2596
0
        assert(dictionary != NULL);
2597
0
        lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
2598
0
    } else {
2599
0
        lz4sd->prefixEnd = (const BYTE*) dictionary;
2600
0
    }
2601
0
    lz4sd->externalDict = NULL;
2602
0
    lz4sd->extDictSize  = 0;
2603
0
    return 1;
2604
0
}
2605
2606
/*! LZ4_decoderRingBufferSize() :
2607
 *  when setting a ring buffer for streaming decompression (optional scenario),
2608
 *  provides the minimum size of this ring buffer
2609
 *  to be compatible with any source respecting maxBlockSize condition.
2610
 *  Note : in a ring buffer scenario,
2611
 *  blocks are presumed decompressed next to each other.
2612
 *  When not enough space remains for next block (remainingSize < maxBlockSize),
2613
 *  decoding resumes from beginning of ring buffer.
2614
 * @return : minimum ring buffer size,
2615
 *           or 0 if there is an error (invalid maxBlockSize).
2616
 */
2617
int LZ4_decoderRingBufferSize(int maxBlockSize)
2618
0
{
2619
0
    if (maxBlockSize < 0) return 0;
2620
0
    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
2621
0
    if (maxBlockSize < 16) maxBlockSize = 16;
2622
0
    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
2623
0
}
2624
2625
/*
2626
*_continue() :
2627
    These decoding functions allow decompression of multiple blocks in "streaming" mode.
2628
    Previously decoded blocks must still be available at the memory position where they were decoded.
2629
    If it's not possible, save the relevant part of decoded data into a safe buffer,
2630
    and indicate where it stands using LZ4_setStreamDecode()
2631
*/
2632
LZ4_FORCE_O2
2633
int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
2634
0
{
2635
0
    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
2636
0
    int result;
2637
2638
0
    if (lz4sd->prefixSize == 0) {
2639
        /* The first call, no dictionary yet. */
2640
0
        assert(lz4sd->extDictSize == 0);
2641
0
        result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
2642
0
        if (result <= 0) return result;
2643
0
        lz4sd->prefixSize = (size_t)result;
2644
0
        lz4sd->prefixEnd = (BYTE*)dest + result;
2645
0
    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
2646
        /* They're rolling the current segment. */
2647
0
        if (lz4sd->prefixSize >= 64 KB - 1)
2648
0
            result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
2649
0
        else if (lz4sd->extDictSize == 0)
2650
0
            result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize,
2651
0
                                                         lz4sd->prefixSize);
2652
0
        else
2653
0
            result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize,
2654
0
                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
2655
0
        if (result <= 0) return result;
2656
0
        lz4sd->prefixSize += (size_t)result;
2657
0
        lz4sd->prefixEnd  += result;
2658
0
    } else {
2659
        /* The buffer wraps around, or they're switching to another buffer. */
2660
0
        lz4sd->extDictSize = lz4sd->prefixSize;
2661
0
        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
2662
0
        result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize,
2663
0
                                                  lz4sd->externalDict, lz4sd->extDictSize);
2664
0
        if (result <= 0) return result;
2665
0
        lz4sd->prefixSize = (size_t)result;
2666
0
        lz4sd->prefixEnd  = (BYTE*)dest + result;
2667
0
    }
2668
2669
0
    return result;
2670
0
}
2671
2672
LZ4_FORCE_O2 int
2673
LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode,
2674
                        const char* source, char* dest, int originalSize)
2675
0
{
2676
0
    LZ4_streamDecode_t_internal* const lz4sd =
2677
0
        (assert(LZ4_streamDecode!=NULL), &LZ4_streamDecode->internal_donotuse);
2678
0
    int result;
2679
2680
0
    DEBUGLOG(5, "LZ4_decompress_fast_continue (toDecodeSize=%i)", originalSize);
2681
0
    assert(originalSize >= 0);
2682
2683
0
    if (lz4sd->prefixSize == 0) {
2684
0
        DEBUGLOG(5, "first invocation : no prefix nor extDict");
2685
0
        assert(lz4sd->extDictSize == 0);
2686
0
        result = LZ4_decompress_fast(source, dest, originalSize);
2687
0
        if (result <= 0) return result;
2688
0
        lz4sd->prefixSize = (size_t)originalSize;
2689
0
        lz4sd->prefixEnd = (BYTE*)dest + originalSize;
2690
0
    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
2691
0
        DEBUGLOG(5, "continue using existing prefix");
2692
0
        result = LZ4_decompress_unsafe_generic(
2693
0
                        (const BYTE*)source, (BYTE*)dest, originalSize,
2694
0
                        lz4sd->prefixSize,
2695
0
                        lz4sd->externalDict, lz4sd->extDictSize);
2696
0
        if (result <= 0) return result;
2697
0
        lz4sd->prefixSize += (size_t)originalSize;
2698
0
        lz4sd->prefixEnd  += originalSize;
2699
0
    } else {
2700
0
        DEBUGLOG(5, "prefix becomes extDict");
2701
0
        lz4sd->extDictSize = lz4sd->prefixSize;
2702
0
        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
2703
0
        result = LZ4_decompress_fast_extDict(source, dest, originalSize,
2704
0
                                             lz4sd->externalDict, lz4sd->extDictSize);
2705
0
        if (result <= 0) return result;
2706
0
        lz4sd->prefixSize = (size_t)originalSize;
2707
0
        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
2708
0
    }
2709
2710
0
    return result;
2711
0
}
2712
2713
2714
/*
2715
Advanced decoding functions :
2716
*_usingDict() :
2717
    These decoding functions work the same as "_continue" ones,
2718
    the dictionary must be explicitly provided within parameters
2719
*/
2720
2721
int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
2722
5.21k
{
2723
5.21k
    if (dictSize==0)
2724
1.04k
        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
2725
4.17k
    if (dictStart+dictSize == dest) {
2726
0
        if (dictSize >= 64 KB - 1) {
2727
0
            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
2728
0
        }
2729
0
        assert(dictSize >= 0);
2730
0
        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
2731
0
    }
2732
4.17k
    assert(dictSize >= 0);
2733
4.17k
    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
2734
4.17k
}
2735
2736
int LZ4_decompress_safe_partial_usingDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const char* dictStart, int dictSize)
2737
5.21k
{
2738
5.21k
    if (dictSize==0)
2739
1.04k
        return LZ4_decompress_safe_partial(source, dest, compressedSize, targetOutputSize, dstCapacity);
2740
4.17k
    if (dictStart+dictSize == dest) {
2741
0
        if (dictSize >= 64 KB - 1) {
2742
0
            return LZ4_decompress_safe_partial_withPrefix64k(source, dest, compressedSize, targetOutputSize, dstCapacity);
2743
0
        }
2744
0
        assert(dictSize >= 0);
2745
0
        return LZ4_decompress_safe_partial_withSmallPrefix(source, dest, compressedSize, targetOutputSize, dstCapacity, (size_t)dictSize);
2746
0
    }
2747
4.17k
    assert(dictSize >= 0);
2748
4.17k
    return LZ4_decompress_safe_partial_forceExtDict(source, dest, compressedSize, targetOutputSize, dstCapacity, dictStart, (size_t)dictSize);
2749
4.17k
}
2750
2751
int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
2752
0
{
2753
0
    if (dictSize==0 || dictStart+dictSize == dest)
2754
0
        return LZ4_decompress_unsafe_generic(
2755
0
                        (const BYTE*)source, (BYTE*)dest, originalSize,
2756
0
                        (size_t)dictSize, NULL, 0);
2757
0
    assert(dictSize >= 0);
2758
0
    return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize);
2759
0
}
2760
2761
2762
/*=*************************************************
2763
*  Obsolete Functions
2764
***************************************************/
2765
/* obsolete compression functions */
2766
int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
2767
0
{
2768
0
    return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
2769
0
}
2770
int LZ4_compress(const char* src, char* dest, int srcSize)
2771
0
{
2772
0
    return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize));
2773
0
}
2774
int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize)
2775
0
{
2776
0
    return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
2777
0
}
2778
int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize)
2779
0
{
2780
0
    return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
2781
0
}
2782
int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity)
2783
0
{
2784
0
    return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
2785
0
}
2786
int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize)
2787
0
{
2788
0
    return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
2789
0
}
2790
2791
/*
2792
These decompression functions are deprecated and should no longer be used.
2793
They are only provided here for compatibility with older user programs.
2794
- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
2795
- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
2796
*/
2797
int LZ4_uncompress (const char* source, char* dest, int outputSize)
2798
0
{
2799
0
    return LZ4_decompress_fast(source, dest, outputSize);
2800
0
}
2801
int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize)
2802
0
{
2803
0
    return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
2804
0
}
2805
2806
/* Obsolete Streaming functions */
2807
2808
0
int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); }
2809
2810
int LZ4_resetStreamState(void* state, char* inputBuffer)
2811
0
{
2812
0
    (void)inputBuffer;
2813
0
    LZ4_resetStream((LZ4_stream_t*)state);
2814
0
    return 0;
2815
0
}
2816
2817
#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
2818
void* LZ4_create (char* inputBuffer)
2819
0
{
2820
0
    (void)inputBuffer;
2821
0
    return LZ4_createStream();
2822
0
}
2823
#endif
2824
2825
char* LZ4_slideInputBuffer (void* state)
2826
0
{
2827
    /* avoid const char * -> char * conversion warning */
2828
0
    return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary;
2829
0
}
2830
2831
#endif   /* LZ4_COMMONDEFS_ONLY */