1 /* ******************************************************************
2  * huff0 huffman decoder,
3  * part of Finite State Entropy library
4  * Copyright (c) Yann Collet, Facebook, Inc.
5  *
6  *  You can contact the author at :
7  *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
8  *
9  * This source code is licensed under both the BSD-style license (found in the
10  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
11  * in the COPYING file in the root directory of this source tree).
12  * You may select, at your option, one of the above-listed licenses.
13 ****************************************************************** */
14 
15 /* **************************************************************
16 *  Dependencies
17 ****************************************************************/
18 #include "../common/zstd_deps.h"  /* ZSTD_memcpy, ZSTD_memset */
19 #include "../common/compiler.h"
20 #include "../common/bitstream.h"  /* BIT_* */
21 #include "../common/fse.h"        /* to compress headers */
22 #define HUF_STATIC_LINKING_ONLY
23 #include "../common/huf.h"
24 #include "../common/error_private.h"
25 #include "../common/zstd_internal.h"
26 
27 /* **************************************************************
28 *  Constants
29 ****************************************************************/
30 
31 #define HUF_DECODER_FAST_TABLELOG 11
32 
33 /* **************************************************************
34 *  Macros
35 ****************************************************************/
36 
37 /* These two optional macros force the use one way or another of the two
38  * Huffman decompression implementations. You can't force in both directions
39  * at the same time.
40  */
41 #if defined(HUF_FORCE_DECOMPRESS_X1) && \
42     defined(HUF_FORCE_DECOMPRESS_X2)
43 #error "Cannot force the use of the X1 and X2 decoders at the same time!"
44 #endif
45 
46 #if ZSTD_ENABLE_ASM_X86_64_BMI2 && DYNAMIC_BMI2
47 # define HUF_ASM_X86_64_BMI2_ATTRS BMI2_TARGET_ATTRIBUTE
48 #else
49 # define HUF_ASM_X86_64_BMI2_ATTRS
50 #endif
51 
52 #define HUF_EXTERN_C
53 #define HUF_ASM_DECL HUF_EXTERN_C
54 
55 #if DYNAMIC_BMI2 || (ZSTD_ENABLE_ASM_X86_64_BMI2 && defined(__BMI2__))
56 # define HUF_NEED_BMI2_FUNCTION 1
57 #else
58 # define HUF_NEED_BMI2_FUNCTION 0
59 #endif
60 
61 #if !(ZSTD_ENABLE_ASM_X86_64_BMI2 && defined(__BMI2__))
62 # define HUF_NEED_DEFAULT_FUNCTION 1
63 #else
64 # define HUF_NEED_DEFAULT_FUNCTION 0
65 #endif
66 
67 /* **************************************************************
68 *  Error Management
69 ****************************************************************/
70 #define HUF_isError ERR_isError
71 
72 
73 /* **************************************************************
74 *  Byte alignment for workSpace management
75 ****************************************************************/
76 #define HUF_ALIGN(x, a)         HUF_ALIGN_MASK((x), (a) - 1)
77 #define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
78 
79 
80 /* **************************************************************
81 *  BMI2 Variant Wrappers
82 ****************************************************************/
83 #if DYNAMIC_BMI2
84 
85 #define HUF_DGEN(fn)                                                        \
86                                                                             \
87     static size_t fn##_default(                                             \
88                   void* dst,  size_t dstSize,                               \
89             const void* cSrc, size_t cSrcSize,                              \
90             const HUF_DTable* DTable)                                       \
91     {                                                                       \
92         return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
93     }                                                                       \
94                                                                             \
95     static BMI2_TARGET_ATTRIBUTE size_t fn##_bmi2(                          \
96                   void* dst,  size_t dstSize,                               \
97             const void* cSrc, size_t cSrcSize,                              \
98             const HUF_DTable* DTable)                                       \
99     {                                                                       \
100         return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
101     }                                                                       \
102                                                                             \
103     static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
104                      size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \
105     {                                                                       \
106         if (bmi2) {                                                         \
107             return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);         \
108         }                                                                   \
109         return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable);          \
110     }
111 
112 #else
113 
114 #define HUF_DGEN(fn)                                                        \
115     static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
116                      size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \
117     {                                                                       \
118         (void)bmi2;                                                         \
119         return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
120     }
121 
122 #endif
123 
124 
125 /*-***************************/
126 /*  generic DTableDesc       */
127 /*-***************************/
128 typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
129 
130 static DTableDesc HUF_getDTableDesc(const HUF_DTable* table)
131 {
132     DTableDesc dtd;
133     ZSTD_memcpy(&dtd, table, sizeof(dtd));
134     return dtd;
135 }
136 
137 #if ZSTD_ENABLE_ASM_X86_64_BMI2
138 
139 static size_t HUF_initDStream(BYTE const* ip) {
140     BYTE const lastByte = ip[7];
141     size_t const bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
142     size_t const value = MEM_readLEST(ip) | 1;
143     assert(bitsConsumed <= 8);
144     return value << bitsConsumed;
145 }
146 typedef struct {
147     BYTE const* ip[4];
148     BYTE* op[4];
149     U64 bits[4];
150     void const* dt;
151     BYTE const* ilimit;
152     BYTE* oend;
153     BYTE const* iend[4];
154 } HUF_DecompressAsmArgs;
155 
156 /*
157  * Initializes args for the asm decoding loop.
158  * @returns 0 on success
159  *          1 if the fallback implementation should be used.
160  *          Or an error code on failure.
161  */
162 static size_t HUF_DecompressAsmArgs_init(HUF_DecompressAsmArgs* args, void* dst, size_t dstSize, void const* src, size_t srcSize, const HUF_DTable* DTable)
163 {
164     void const* dt = DTable + 1;
165     U32 const dtLog = HUF_getDTableDesc(DTable).tableLog;
166 
167     const BYTE* const ilimit = (const BYTE*)src + 6 + 8;
168 
169     BYTE* const oend = (BYTE*)dst + dstSize;
170 
171     /* The following condition is false on x32 platform,
172      * but HUF_asm is not compatible with this ABI */
173     if (!(MEM_isLittleEndian() && !MEM_32bits())) return 1;
174 
175     /* strict minimum : jump table + 1 byte per stream */
176     if (srcSize < 10)
177         return ERROR(corruption_detected);
178 
179     /* Must have at least 8 bytes per stream because we don't handle initializing smaller bit containers.
180      * If table log is not correct at this point, fallback to the old decoder.
181      * On small inputs we don't have enough data to trigger the fast loop, so use the old decoder.
182      */
183     if (dtLog != HUF_DECODER_FAST_TABLELOG)
184         return 1;
185 
186     /* Read the jump table. */
187     {
188         const BYTE* const istart = (const BYTE*)src;
189         size_t const length1 = MEM_readLE16(istart);
190         size_t const length2 = MEM_readLE16(istart+2);
191         size_t const length3 = MEM_readLE16(istart+4);
192         size_t const length4 = srcSize - (length1 + length2 + length3 + 6);
193         args->iend[0] = istart + 6;  /* jumpTable */
194         args->iend[1] = args->iend[0] + length1;
195         args->iend[2] = args->iend[1] + length2;
196         args->iend[3] = args->iend[2] + length3;
197 
198         /* HUF_initDStream() requires this, and this small of an input
199          * won't benefit from the ASM loop anyways.
200          * length1 must be >= 16 so that ip[0] >= ilimit before the loop
201          * starts.
202          */
203         if (length1 < 16 || length2 < 8 || length3 < 8 || length4 < 8)
204             return 1;
205         if (length4 > srcSize) return ERROR(corruption_detected);   /* overflow */
206     }
207     /* ip[] contains the position that is currently loaded into bits[]. */
208     args->ip[0] = args->iend[1] - sizeof(U64);
209     args->ip[1] = args->iend[2] - sizeof(U64);
210     args->ip[2] = args->iend[3] - sizeof(U64);
211     args->ip[3] = (BYTE const*)src + srcSize - sizeof(U64);
212 
213     /* op[] contains the output pointers. */
214     args->op[0] = (BYTE*)dst;
215     args->op[1] = args->op[0] + (dstSize+3)/4;
216     args->op[2] = args->op[1] + (dstSize+3)/4;
217     args->op[3] = args->op[2] + (dstSize+3)/4;
218 
219     /* No point to call the ASM loop for tiny outputs. */
220     if (args->op[3] >= oend)
221         return 1;
222 
223     /* bits[] is the bit container.
224         * It is read from the MSB down to the LSB.
225         * It is shifted left as it is read, and zeros are
226         * shifted in. After the lowest valid bit a 1 is
227         * set, so that CountTrailingZeros(bits[]) can be used
228         * to count how many bits we've consumed.
229         */
230     args->bits[0] = HUF_initDStream(args->ip[0]);
231     args->bits[1] = HUF_initDStream(args->ip[1]);
232     args->bits[2] = HUF_initDStream(args->ip[2]);
233     args->bits[3] = HUF_initDStream(args->ip[3]);
234 
235     /* If ip[] >= ilimit, it is guaranteed to be safe to
236         * reload bits[]. It may be beyond its section, but is
237         * guaranteed to be valid (>= istart).
238         */
239     args->ilimit = ilimit;
240 
241     args->oend = oend;
242     args->dt = dt;
243 
244     return 0;
245 }
246 
247 static size_t HUF_initRemainingDStream(BIT_DStream_t* bit, HUF_DecompressAsmArgs const* args, int stream, BYTE* segmentEnd)
248 {
249     /* Validate that we haven't overwritten. */
250     if (args->op[stream] > segmentEnd)
251         return ERROR(corruption_detected);
252     /* Validate that we haven't read beyond iend[].
253         * Note that ip[] may be < iend[] because the MSB is
254         * the next bit to read, and we may have consumed 100%
255         * of the stream, so down to iend[i] - 8 is valid.
256         */
257     if (args->ip[stream] < args->iend[stream] - 8)
258         return ERROR(corruption_detected);
259 
260     /* Construct the BIT_DStream_t. */
261     bit->bitContainer = MEM_readLE64(args->ip[stream]);
262     bit->bitsConsumed = ZSTD_countTrailingZeros((size_t)args->bits[stream]);
263     bit->start = (const char*)args->iend[0];
264     bit->limitPtr = bit->start + sizeof(size_t);
265     bit->ptr = (const char*)args->ip[stream];
266 
267     return 0;
268 }
269 #endif
270 
271 
272 #ifndef HUF_FORCE_DECOMPRESS_X2
273 
274 /*-***************************/
275 /*  single-symbol decoding   */
276 /*-***************************/
277 typedef struct { BYTE nbBits; BYTE byte; } HUF_DEltX1;   /* single-symbol decoding */
278 
279 /*
280  * Packs 4 HUF_DEltX1 structs into a U64. This is used to lay down 4 entries at
281  * a time.
282  */
283 static U64 HUF_DEltX1_set4(BYTE symbol, BYTE nbBits) {
284     U64 D4;
285     if (MEM_isLittleEndian()) {
286         D4 = (symbol << 8) + nbBits;
287     } else {
288         D4 = symbol + (nbBits << 8);
289     }
290     D4 *= 0x0001000100010001ULL;
291     return D4;
292 }
293 
294 /*
295  * Increase the tableLog to targetTableLog and rescales the stats.
296  * If tableLog > targetTableLog this is a no-op.
297  * @returns New tableLog
298  */
299 static U32 HUF_rescaleStats(BYTE* huffWeight, U32* rankVal, U32 nbSymbols, U32 tableLog, U32 targetTableLog)
300 {
301     if (tableLog > targetTableLog)
302         return tableLog;
303     if (tableLog < targetTableLog) {
304         U32 const scale = targetTableLog - tableLog;
305         U32 s;
306         /* Increase the weight for all non-zero probability symbols by scale. */
307         for (s = 0; s < nbSymbols; ++s) {
308             huffWeight[s] += (BYTE)((huffWeight[s] == 0) ? 0 : scale);
309         }
310         /* Update rankVal to reflect the new weights.
311          * All weights except 0 get moved to weight + scale.
312          * Weights [1, scale] are empty.
313          */
314         for (s = targetTableLog; s > scale; --s) {
315             rankVal[s] = rankVal[s - scale];
316         }
317         for (s = scale; s > 0; --s) {
318             rankVal[s] = 0;
319         }
320     }
321     return targetTableLog;
322 }
323 
324 typedef struct {
325         U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];
326         U32 rankStart[HUF_TABLELOG_ABSOLUTEMAX + 1];
327         U32 statsWksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
328         BYTE symbols[HUF_SYMBOLVALUE_MAX + 1];
329         BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];
330 } HUF_ReadDTableX1_Workspace;
331 
332 
333 size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
334 {
335     return HUF_readDTableX1_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0);
336 }
337 
338 size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int bmi2)
339 {
340     U32 tableLog = 0;
341     U32 nbSymbols = 0;
342     size_t iSize;
343     void* const dtPtr = DTable + 1;
344     HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;
345     HUF_ReadDTableX1_Workspace* wksp = (HUF_ReadDTableX1_Workspace*)workSpace;
346 
347     DEBUG_STATIC_ASSERT(HUF_DECOMPRESS_WORKSPACE_SIZE >= sizeof(*wksp));
348     if (sizeof(*wksp) > wkspSize) return ERROR(tableLog_tooLarge);
349 
350     DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
351     /* ZSTD_memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */
352 
353     iSize = HUF_readStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, srcSize, wksp->statsWksp, sizeof(wksp->statsWksp), bmi2);
354     if (HUF_isError(iSize)) return iSize;
355 
356 
357     /* Table header */
358     {   DTableDesc dtd = HUF_getDTableDesc(DTable);
359         U32 const maxTableLog = dtd.maxTableLog + 1;
360         U32 const targetTableLog = MIN(maxTableLog, HUF_DECODER_FAST_TABLELOG);
361         tableLog = HUF_rescaleStats(wksp->huffWeight, wksp->rankVal, nbSymbols, tableLog, targetTableLog);
362         if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, Huffman tree cannot fit in */
363         dtd.tableType = 0;
364         dtd.tableLog = (BYTE)tableLog;
365         ZSTD_memcpy(DTable, &dtd, sizeof(dtd));
366     }
367 
368     /* Compute symbols and rankStart given rankVal:
369      *
370      * rankVal already contains the number of values of each weight.
371      *
372      * symbols contains the symbols ordered by weight. First are the rankVal[0]
373      * weight 0 symbols, followed by the rankVal[1] weight 1 symbols, and so on.
374      * symbols[0] is filled (but unused) to avoid a branch.
375      *
376      * rankStart contains the offset where each rank belongs in the DTable.
377      * rankStart[0] is not filled because there are no entries in the table for
378      * weight 0.
379      */
380     {
381         int n;
382         int nextRankStart = 0;
383         int const unroll = 4;
384         int const nLimit = (int)nbSymbols - unroll + 1;
385         for (n=0; n<(int)tableLog+1; n++) {
386             U32 const curr = nextRankStart;
387             nextRankStart += wksp->rankVal[n];
388             wksp->rankStart[n] = curr;
389         }
390         for (n=0; n < nLimit; n += unroll) {
391             int u;
392             for (u=0; u < unroll; ++u) {
393                 size_t const w = wksp->huffWeight[n+u];
394                 wksp->symbols[wksp->rankStart[w]++] = (BYTE)(n+u);
395             }
396         }
397         for (; n < (int)nbSymbols; ++n) {
398             size_t const w = wksp->huffWeight[n];
399             wksp->symbols[wksp->rankStart[w]++] = (BYTE)n;
400         }
401     }
402 
403     /* fill DTable
404      * We fill all entries of each weight in order.
405      * That way length is a constant for each iteration of the outer loop.
406      * We can switch based on the length to a different inner loop which is
407      * optimized for that particular case.
408      */
409     {
410         U32 w;
411         int symbol=wksp->rankVal[0];
412         int rankStart=0;
413         for (w=1; w<tableLog+1; ++w) {
414             int const symbolCount = wksp->rankVal[w];
415             int const length = (1 << w) >> 1;
416             int uStart = rankStart;
417             BYTE const nbBits = (BYTE)(tableLog + 1 - w);
418             int s;
419             int u;
420             switch (length) {
421             case 1:
422                 for (s=0; s<symbolCount; ++s) {
423                     HUF_DEltX1 D;
424                     D.byte = wksp->symbols[symbol + s];
425                     D.nbBits = nbBits;
426                     dt[uStart] = D;
427                     uStart += 1;
428                 }
429                 break;
430             case 2:
431                 for (s=0; s<symbolCount; ++s) {
432                     HUF_DEltX1 D;
433                     D.byte = wksp->symbols[symbol + s];
434                     D.nbBits = nbBits;
435                     dt[uStart+0] = D;
436                     dt[uStart+1] = D;
437                     uStart += 2;
438                 }
439                 break;
440             case 4:
441                 for (s=0; s<symbolCount; ++s) {
442                     U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits);
443                     MEM_write64(dt + uStart, D4);
444                     uStart += 4;
445                 }
446                 break;
447             case 8:
448                 for (s=0; s<symbolCount; ++s) {
449                     U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits);
450                     MEM_write64(dt + uStart, D4);
451                     MEM_write64(dt + uStart + 4, D4);
452                     uStart += 8;
453                 }
454                 break;
455             default:
456                 for (s=0; s<symbolCount; ++s) {
457                     U64 const D4 = HUF_DEltX1_set4(wksp->symbols[symbol + s], nbBits);
458                     for (u=0; u < length; u += 16) {
459                         MEM_write64(dt + uStart + u + 0, D4);
460                         MEM_write64(dt + uStart + u + 4, D4);
461                         MEM_write64(dt + uStart + u + 8, D4);
462                         MEM_write64(dt + uStart + u + 12, D4);
463                     }
464                     assert(u == length);
465                     uStart += length;
466                 }
467                 break;
468             }
469             symbol += symbolCount;
470             rankStart += symbolCount * length;
471         }
472     }
473     return iSize;
474 }
475 
476 FORCE_INLINE_TEMPLATE BYTE
477 HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
478 {
479     size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
480     BYTE const c = dt[val].byte;
481     BIT_skipBits(Dstream, dt[val].nbBits);
482     return c;
483 }
484 
485 #define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
486     *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog)
487 
488 #define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)  \
489     if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
490         HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
491 
492 #define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \
493     if (MEM_64bits()) \
494         HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
495 
496 HINT_INLINE size_t
497 HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
498 {
499     BYTE* const pStart = p;
500 
501     /* up to 4 symbols at a time */
502     if ((pEnd - p) > 3) {
503         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {
504             HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
505             HUF_DECODE_SYMBOLX1_1(p, bitDPtr);
506             HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
507             HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
508         }
509     } else {
510         BIT_reloadDStream(bitDPtr);
511     }
512 
513     /* [0-3] symbols remaining */
514     if (MEM_32bits())
515         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
516             HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
517 
518     /* no more data to retrieve from bitstream, no need to reload */
519     while (p < pEnd)
520         HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
521 
522     return pEnd-pStart;
523 }
524 
525 FORCE_INLINE_TEMPLATE size_t
526 HUF_decompress1X1_usingDTable_internal_body(
527           void* dst,  size_t dstSize,
528     const void* cSrc, size_t cSrcSize,
529     const HUF_DTable* DTable)
530 {
531     BYTE* op = (BYTE*)dst;
532     BYTE* const oend = op + dstSize;
533     const void* dtPtr = DTable + 1;
534     const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
535     BIT_DStream_t bitD;
536     DTableDesc const dtd = HUF_getDTableDesc(DTable);
537     U32 const dtLog = dtd.tableLog;
538 
539     CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
540 
541     HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);
542 
543     if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
544 
545     return dstSize;
546 }
547 
548 FORCE_INLINE_TEMPLATE size_t
549 HUF_decompress4X1_usingDTable_internal_body(
550           void* dst,  size_t dstSize,
551     const void* cSrc, size_t cSrcSize,
552     const HUF_DTable* DTable)
553 {
554     /* Check */
555     if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */
556 
557     {   const BYTE* const istart = (const BYTE*) cSrc;
558         BYTE* const ostart = (BYTE*) dst;
559         BYTE* const oend = ostart + dstSize;
560         BYTE* const olimit = oend - 3;
561         const void* const dtPtr = DTable + 1;
562         const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
563 
564         /* Init */
565         BIT_DStream_t bitD1;
566         BIT_DStream_t bitD2;
567         BIT_DStream_t bitD3;
568         BIT_DStream_t bitD4;
569         size_t const length1 = MEM_readLE16(istart);
570         size_t const length2 = MEM_readLE16(istart+2);
571         size_t const length3 = MEM_readLE16(istart+4);
572         size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
573         const BYTE* const istart1 = istart + 6;  /* jumpTable */
574         const BYTE* const istart2 = istart1 + length1;
575         const BYTE* const istart3 = istart2 + length2;
576         const BYTE* const istart4 = istart3 + length3;
577         const size_t segmentSize = (dstSize+3) / 4;
578         BYTE* const opStart2 = ostart + segmentSize;
579         BYTE* const opStart3 = opStart2 + segmentSize;
580         BYTE* const opStart4 = opStart3 + segmentSize;
581         BYTE* op1 = ostart;
582         BYTE* op2 = opStart2;
583         BYTE* op3 = opStart3;
584         BYTE* op4 = opStart4;
585         DTableDesc const dtd = HUF_getDTableDesc(DTable);
586         U32 const dtLog = dtd.tableLog;
587         U32 endSignal = 1;
588 
589         if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
590         if (opStart4 > oend) return ERROR(corruption_detected);      /* overflow */
591         CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
592         CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
593         CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
594         CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
595 
596         /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */
597         if ((size_t)(oend - op4) >= sizeof(size_t)) {
598             for ( ; (endSignal) & (op4 < olimit) ; ) {
599                 HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
600                 HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
601                 HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
602                 HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
603                 HUF_DECODE_SYMBOLX1_1(op1, &bitD1);
604                 HUF_DECODE_SYMBOLX1_1(op2, &bitD2);
605                 HUF_DECODE_SYMBOLX1_1(op3, &bitD3);
606                 HUF_DECODE_SYMBOLX1_1(op4, &bitD4);
607                 HUF_DECODE_SYMBOLX1_2(op1, &bitD1);
608                 HUF_DECODE_SYMBOLX1_2(op2, &bitD2);
609                 HUF_DECODE_SYMBOLX1_2(op3, &bitD3);
610                 HUF_DECODE_SYMBOLX1_2(op4, &bitD4);
611                 HUF_DECODE_SYMBOLX1_0(op1, &bitD1);
612                 HUF_DECODE_SYMBOLX1_0(op2, &bitD2);
613                 HUF_DECODE_SYMBOLX1_0(op3, &bitD3);
614                 HUF_DECODE_SYMBOLX1_0(op4, &bitD4);
615                 endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
616                 endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
617                 endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
618                 endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
619             }
620         }
621 
622         /* check corruption */
623         /* note : should not be necessary : op# advance in lock step, and we control op4.
624          *        but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */
625         if (op1 > opStart2) return ERROR(corruption_detected);
626         if (op2 > opStart3) return ERROR(corruption_detected);
627         if (op3 > opStart4) return ERROR(corruption_detected);
628         /* note : op4 supposed already verified within main loop */
629 
630         /* finish bitStreams one by one */
631         HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
632         HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
633         HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
634         HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog);
635 
636         /* check */
637         { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
638           if (!endCheck) return ERROR(corruption_detected); }
639 
640         /* decoded size */
641         return dstSize;
642     }
643 }
644 
645 #if HUF_NEED_BMI2_FUNCTION
646 static BMI2_TARGET_ATTRIBUTE
647 size_t HUF_decompress4X1_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,
648                     size_t cSrcSize, HUF_DTable const* DTable) {
649     return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
650 }
651 #endif
652 
653 #if HUF_NEED_DEFAULT_FUNCTION
654 static
655 size_t HUF_decompress4X1_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,
656                     size_t cSrcSize, HUF_DTable const* DTable) {
657     return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
658 }
659 #endif
660 
661 #if ZSTD_ENABLE_ASM_X86_64_BMI2
662 
663 HUF_ASM_DECL void HUF_decompress4X1_usingDTable_internal_bmi2_asm_loop(HUF_DecompressAsmArgs* args) ZSTDLIB_HIDDEN;
664 
665 static HUF_ASM_X86_64_BMI2_ATTRS
666 size_t
667 HUF_decompress4X1_usingDTable_internal_bmi2_asm(
668           void* dst,  size_t dstSize,
669     const void* cSrc, size_t cSrcSize,
670     const HUF_DTable* DTable)
671 {
672     void const* dt = DTable + 1;
673     const BYTE* const iend = (const BYTE*)cSrc + 6;
674     BYTE* const oend = (BYTE*)dst + dstSize;
675     HUF_DecompressAsmArgs args;
676     {
677         size_t const ret = HUF_DecompressAsmArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);
678         FORWARD_IF_ERROR(ret, "Failed to init asm args");
679         if (ret != 0)
680             return HUF_decompress4X1_usingDTable_internal_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);
681     }
682 
683     assert(args.ip[0] >= args.ilimit);
684     HUF_decompress4X1_usingDTable_internal_bmi2_asm_loop(&args);
685 
686     /* Our loop guarantees that ip[] >= ilimit and that we haven't
687     * overwritten any op[].
688     */
689     assert(args.ip[0] >= iend);
690     assert(args.ip[1] >= iend);
691     assert(args.ip[2] >= iend);
692     assert(args.ip[3] >= iend);
693     assert(args.op[3] <= oend);
694     (void)iend;
695 
696     /* finish bit streams one by one. */
697     {
698         size_t const segmentSize = (dstSize+3) / 4;
699         BYTE* segmentEnd = (BYTE*)dst;
700         int i;
701         for (i = 0; i < 4; ++i) {
702             BIT_DStream_t bit;
703             if (segmentSize <= (size_t)(oend - segmentEnd))
704                 segmentEnd += segmentSize;
705             else
706                 segmentEnd = oend;
707             FORWARD_IF_ERROR(HUF_initRemainingDStream(&bit, &args, i, segmentEnd), "corruption");
708             /* Decompress and validate that we've produced exactly the expected length. */
709             args.op[i] += HUF_decodeStreamX1(args.op[i], &bit, segmentEnd, (HUF_DEltX1 const*)dt, HUF_DECODER_FAST_TABLELOG);
710             if (args.op[i] != segmentEnd) return ERROR(corruption_detected);
711         }
712     }
713 
714     /* decoded size */
715     return dstSize;
716 }
717 #endif /* ZSTD_ENABLE_ASM_X86_64_BMI2 */
718 
719 typedef size_t (*HUF_decompress_usingDTable_t)(void *dst, size_t dstSize,
720                                                const void *cSrc,
721                                                size_t cSrcSize,
722                                                const HUF_DTable *DTable);
723 
724 HUF_DGEN(HUF_decompress1X1_usingDTable_internal)
725 
726 static size_t HUF_decompress4X1_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,
727                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)
728 {
729 #if DYNAMIC_BMI2
730     if (bmi2) {
731 # if ZSTD_ENABLE_ASM_X86_64_BMI2
732         return HUF_decompress4X1_usingDTable_internal_bmi2_asm(dst, dstSize, cSrc, cSrcSize, DTable);
733 # else
734         return HUF_decompress4X1_usingDTable_internal_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);
735 # endif
736     }
737 #else
738     (void)bmi2;
739 #endif
740 
741 #if ZSTD_ENABLE_ASM_X86_64_BMI2 && defined(__BMI2__)
742     return HUF_decompress4X1_usingDTable_internal_bmi2_asm(dst, dstSize, cSrc, cSrcSize, DTable);
743 #else
744     return HUF_decompress4X1_usingDTable_internal_default(dst, dstSize, cSrc, cSrcSize, DTable);
745 #endif
746 }
747 
748 
749 size_t HUF_decompress1X1_usingDTable(
750           void* dst,  size_t dstSize,
751     const void* cSrc, size_t cSrcSize,
752     const HUF_DTable* DTable)
753 {
754     DTableDesc dtd = HUF_getDTableDesc(DTable);
755     if (dtd.tableType != 0) return ERROR(GENERIC);
756     return HUF_decompress1X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
757 }
758 
759 size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
760                                    const void* cSrc, size_t cSrcSize,
761                                    void* workSpace, size_t wkspSize)
762 {
763     const BYTE* ip = (const BYTE*) cSrc;
764 
765     size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize);
766     if (HUF_isError(hSize)) return hSize;
767     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
768     ip += hSize; cSrcSize -= hSize;
769 
770     return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
771 }
772 
773 
774 size_t HUF_decompress4X1_usingDTable(
775           void* dst,  size_t dstSize,
776     const void* cSrc, size_t cSrcSize,
777     const HUF_DTable* DTable)
778 {
779     DTableDesc dtd = HUF_getDTableDesc(DTable);
780     if (dtd.tableType != 0) return ERROR(GENERIC);
781     return HUF_decompress4X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
782 }
783 
784 static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
785                                    const void* cSrc, size_t cSrcSize,
786                                    void* workSpace, size_t wkspSize, int bmi2)
787 {
788     const BYTE* ip = (const BYTE*) cSrc;
789 
790     size_t const hSize = HUF_readDTableX1_wksp_bmi2(dctx, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
791     if (HUF_isError(hSize)) return hSize;
792     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
793     ip += hSize; cSrcSize -= hSize;
794 
795     return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
796 }
797 
798 size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
799                                    const void* cSrc, size_t cSrcSize,
800                                    void* workSpace, size_t wkspSize)
801 {
802     return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0);
803 }
804 
805 
806 #endif /* HUF_FORCE_DECOMPRESS_X2 */
807 
808 
809 #ifndef HUF_FORCE_DECOMPRESS_X1
810 
811 /* *************************/
812 /* double-symbols decoding */
813 /* *************************/
814 
815 typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2;  /* double-symbols decoding */
816 typedef struct { BYTE symbol; } sortedSymbol_t;
817 typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
818 typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];
819 
820 /*
821  * Constructs a HUF_DEltX2 in a U32.
822  */
823 static U32 HUF_buildDEltX2U32(U32 symbol, U32 nbBits, U32 baseSeq, int level)
824 {
825     U32 seq;
826     DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, sequence) == 0);
827     DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, nbBits) == 2);
828     DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, length) == 3);
829     DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U32));
830     if (MEM_isLittleEndian()) {
831         seq = level == 1 ? symbol : (baseSeq + (symbol << 8));
832         return seq + (nbBits << 16) + ((U32)level << 24);
833     } else {
834         seq = level == 1 ? (symbol << 8) : ((baseSeq << 8) + symbol);
835         return (seq << 16) + (nbBits << 8) + (U32)level;
836     }
837 }
838 
839 /*
840  * Constructs a HUF_DEltX2.
841  */
842 static HUF_DEltX2 HUF_buildDEltX2(U32 symbol, U32 nbBits, U32 baseSeq, int level)
843 {
844     HUF_DEltX2 DElt;
845     U32 const val = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);
846     DEBUG_STATIC_ASSERT(sizeof(DElt) == sizeof(val));
847     ZSTD_memcpy(&DElt, &val, sizeof(val));
848     return DElt;
849 }
850 
851 /*
852  * Constructs 2 HUF_DEltX2s and packs them into a U64.
853  */
854 static U64 HUF_buildDEltX2U64(U32 symbol, U32 nbBits, U16 baseSeq, int level)
855 {
856     U32 DElt = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);
857     return (U64)DElt + ((U64)DElt << 32);
858 }
859 
860 /*
861  * Fills the DTable rank with all the symbols from [begin, end) that are each
862  * nbBits long.
863  *
864  * @param DTableRank The start of the rank in the DTable.
865  * @param begin The first symbol to fill (inclusive).
866  * @param end The last symbol to fill (exclusive).
867  * @param nbBits Each symbol is nbBits long.
868  * @param tableLog The table log.
869  * @param baseSeq If level == 1 { 0 } else { the first level symbol }
870  * @param level The level in the table. Must be 1 or 2.
871  */
872 static void HUF_fillDTableX2ForWeight(
873     HUF_DEltX2* DTableRank,
874     sortedSymbol_t const* begin, sortedSymbol_t const* end,
875     U32 nbBits, U32 tableLog,
876     U16 baseSeq, int const level)
877 {
878     U32 const length = 1U << ((tableLog - nbBits) & 0x1F /* quiet static-analyzer */);
879     const sortedSymbol_t* ptr;
880     assert(level >= 1 && level <= 2);
881     switch (length) {
882     case 1:
883         for (ptr = begin; ptr != end; ++ptr) {
884             HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level);
885             *DTableRank++ = DElt;
886         }
887         break;
888     case 2:
889         for (ptr = begin; ptr != end; ++ptr) {
890             HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level);
891             DTableRank[0] = DElt;
892             DTableRank[1] = DElt;
893             DTableRank += 2;
894         }
895         break;
896     case 4:
897         for (ptr = begin; ptr != end; ++ptr) {
898             U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);
899             ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));
900             ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));
901             DTableRank += 4;
902         }
903         break;
904     case 8:
905         for (ptr = begin; ptr != end; ++ptr) {
906             U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);
907             ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));
908             ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));
909             ZSTD_memcpy(DTableRank + 4, &DEltX2, sizeof(DEltX2));
910             ZSTD_memcpy(DTableRank + 6, &DEltX2, sizeof(DEltX2));
911             DTableRank += 8;
912         }
913         break;
914     default:
915         for (ptr = begin; ptr != end; ++ptr) {
916             U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);
917             HUF_DEltX2* const DTableRankEnd = DTableRank + length;
918             for (; DTableRank != DTableRankEnd; DTableRank += 8) {
919                 ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));
920                 ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));
921                 ZSTD_memcpy(DTableRank + 4, &DEltX2, sizeof(DEltX2));
922                 ZSTD_memcpy(DTableRank + 6, &DEltX2, sizeof(DEltX2));
923             }
924         }
925         break;
926     }
927 }
928 
929 /* HUF_fillDTableX2Level2() :
930  * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */
931 static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 targetLog, const U32 consumedBits,
932                            const U32* rankVal, const int minWeight, const int maxWeight1,
933                            const sortedSymbol_t* sortedSymbols, U32 const* rankStart,
934                            U32 nbBitsBaseline, U16 baseSeq)
935 {
936     /* Fill skipped values (all positions up to rankVal[minWeight]).
937      * These are positions only get a single symbol because the combined weight
938      * is too large.
939      */
940     if (minWeight>1) {
941         U32 const length = 1U << ((targetLog - consumedBits) & 0x1F /* quiet static-analyzer */);
942         U64 const DEltX2 = HUF_buildDEltX2U64(baseSeq, consumedBits, /* baseSeq */ 0, /* level */ 1);
943         int const skipSize = rankVal[minWeight];
944         assert(length > 1);
945         assert((U32)skipSize < length);
946         switch (length) {
947         case 2:
948             assert(skipSize == 1);
949             ZSTD_memcpy(DTable, &DEltX2, sizeof(DEltX2));
950             break;
951         case 4:
952             assert(skipSize <= 4);
953             ZSTD_memcpy(DTable + 0, &DEltX2, sizeof(DEltX2));
954             ZSTD_memcpy(DTable + 2, &DEltX2, sizeof(DEltX2));
955             break;
956         default:
957             {
958                 int i;
959                 for (i = 0; i < skipSize; i += 8) {
960                     ZSTD_memcpy(DTable + i + 0, &DEltX2, sizeof(DEltX2));
961                     ZSTD_memcpy(DTable + i + 2, &DEltX2, sizeof(DEltX2));
962                     ZSTD_memcpy(DTable + i + 4, &DEltX2, sizeof(DEltX2));
963                     ZSTD_memcpy(DTable + i + 6, &DEltX2, sizeof(DEltX2));
964                 }
965             }
966         }
967     }
968 
969     /* Fill each of the second level symbols by weight. */
970     {
971         int w;
972         for (w = minWeight; w < maxWeight1; ++w) {
973             int const begin = rankStart[w];
974             int const end = rankStart[w+1];
975             U32 const nbBits = nbBitsBaseline - w;
976             U32 const totalBits = nbBits + consumedBits;
977             HUF_fillDTableX2ForWeight(
978                 DTable + rankVal[w],
979                 sortedSymbols + begin, sortedSymbols + end,
980                 totalBits, targetLog,
981                 baseSeq, /* level */ 2);
982         }
983     }
984 }
985 
986 static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
987                            const sortedSymbol_t* sortedList,
988                            const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
989                            const U32 nbBitsBaseline)
990 {
991     U32* const rankVal = rankValOrigin[0];
992     const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
993     const U32 minBits  = nbBitsBaseline - maxWeight;
994     int w;
995     int const wEnd = (int)maxWeight + 1;
996 
997     /* Fill DTable in order of weight. */
998     for (w = 1; w < wEnd; ++w) {
999         int const begin = (int)rankStart[w];
1000         int const end = (int)rankStart[w+1];
1001         U32 const nbBits = nbBitsBaseline - w;
1002 
1003         if (targetLog-nbBits >= minBits) {
1004             /* Enough room for a second symbol. */
1005             int start = rankVal[w];
1006             U32 const length = 1U << ((targetLog - nbBits) & 0x1F /* quiet static-analyzer */);
1007             int minWeight = nbBits + scaleLog;
1008             int s;
1009             if (minWeight < 1) minWeight = 1;
1010             /* Fill the DTable for every symbol of weight w.
1011              * These symbols get at least 1 second symbol.
1012              */
1013             for (s = begin; s != end; ++s) {
1014                 HUF_fillDTableX2Level2(
1015                     DTable + start, targetLog, nbBits,
1016                     rankValOrigin[nbBits], minWeight, wEnd,
1017                     sortedList, rankStart,
1018                     nbBitsBaseline, sortedList[s].symbol);
1019                 start += length;
1020             }
1021         } else {
1022             /* Only a single symbol. */
1023             HUF_fillDTableX2ForWeight(
1024                 DTable + rankVal[w],
1025                 sortedList + begin, sortedList + end,
1026                 nbBits, targetLog,
1027                 /* baseSeq */ 0, /* level */ 1);
1028         }
1029     }
1030 }
1031 
1032 typedef struct {
1033     rankValCol_t rankVal[HUF_TABLELOG_MAX];
1034     U32 rankStats[HUF_TABLELOG_MAX + 1];
1035     U32 rankStart0[HUF_TABLELOG_MAX + 3];
1036     sortedSymbol_t sortedSymbol[HUF_SYMBOLVALUE_MAX + 1];
1037     BYTE weightList[HUF_SYMBOLVALUE_MAX + 1];
1038     U32 calleeWksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
1039 } HUF_ReadDTableX2_Workspace;
1040 
1041 size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
1042                        const void* src, size_t srcSize,
1043                              void* workSpace, size_t wkspSize)
1044 {
1045     return HUF_readDTableX2_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0);
1046 }
1047 
1048 size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
1049                        const void* src, size_t srcSize,
1050                              void* workSpace, size_t wkspSize, int bmi2)
1051 {
1052     U32 tableLog, maxW, nbSymbols;
1053     DTableDesc dtd = HUF_getDTableDesc(DTable);
1054     U32 maxTableLog = dtd.maxTableLog;
1055     size_t iSize;
1056     void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */
1057     HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
1058     U32 *rankStart;
1059 
1060     HUF_ReadDTableX2_Workspace* const wksp = (HUF_ReadDTableX2_Workspace*)workSpace;
1061 
1062     if (sizeof(*wksp) > wkspSize) return ERROR(GENERIC);
1063 
1064     rankStart = wksp->rankStart0 + 1;
1065     ZSTD_memset(wksp->rankStats, 0, sizeof(wksp->rankStats));
1066     ZSTD_memset(wksp->rankStart0, 0, sizeof(wksp->rankStart0));
1067 
1068     DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable));   /* if compiler fails here, assertion is wrong */
1069     if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
1070     /* ZSTD_memset(weightList, 0, sizeof(weightList)); */  /* is not necessary, even though some analyzer complain ... */
1071 
1072     iSize = HUF_readStats_wksp(wksp->weightList, HUF_SYMBOLVALUE_MAX + 1, wksp->rankStats, &nbSymbols, &tableLog, src, srcSize, wksp->calleeWksp, sizeof(wksp->calleeWksp), bmi2);
1073     if (HUF_isError(iSize)) return iSize;
1074 
1075     /* check result */
1076     if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
1077     if (tableLog <= HUF_DECODER_FAST_TABLELOG && maxTableLog > HUF_DECODER_FAST_TABLELOG) maxTableLog = HUF_DECODER_FAST_TABLELOG;
1078 
1079     /* find maxWeight */
1080     for (maxW = tableLog; wksp->rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
1081 
1082     /* Get start index of each weight */
1083     {   U32 w, nextRankStart = 0;
1084         for (w=1; w<maxW+1; w++) {
1085             U32 curr = nextRankStart;
1086             nextRankStart += wksp->rankStats[w];
1087             rankStart[w] = curr;
1088         }
1089         rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
1090         rankStart[maxW+1] = nextRankStart;
1091     }
1092 
1093     /* sort symbols by weight */
1094     {   U32 s;
1095         for (s=0; s<nbSymbols; s++) {
1096             U32 const w = wksp->weightList[s];
1097             U32 const r = rankStart[w]++;
1098             wksp->sortedSymbol[r].symbol = (BYTE)s;
1099         }
1100         rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
1101     }
1102 
1103     /* Build rankVal */
1104     {   U32* const rankVal0 = wksp->rankVal[0];
1105         {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */
1106             U32 nextRankVal = 0;
1107             U32 w;
1108             for (w=1; w<maxW+1; w++) {
1109                 U32 curr = nextRankVal;
1110                 nextRankVal += wksp->rankStats[w] << (w+rescale);
1111                 rankVal0[w] = curr;
1112         }   }
1113         {   U32 const minBits = tableLog+1 - maxW;
1114             U32 consumed;
1115             for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
1116                 U32* const rankValPtr = wksp->rankVal[consumed];
1117                 U32 w;
1118                 for (w = 1; w < maxW+1; w++) {
1119                     rankValPtr[w] = rankVal0[w] >> consumed;
1120     }   }   }   }
1121 
1122     HUF_fillDTableX2(dt, maxTableLog,
1123                    wksp->sortedSymbol,
1124                    wksp->rankStart0, wksp->rankVal, maxW,
1125                    tableLog+1);
1126 
1127     dtd.tableLog = (BYTE)maxTableLog;
1128     dtd.tableType = 1;
1129     ZSTD_memcpy(DTable, &dtd, sizeof(dtd));
1130     return iSize;
1131 }
1132 
1133 
1134 FORCE_INLINE_TEMPLATE U32
1135 HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
1136 {
1137     size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
1138     ZSTD_memcpy(op, &dt[val].sequence, 2);
1139     BIT_skipBits(DStream, dt[val].nbBits);
1140     return dt[val].length;
1141 }
1142 
1143 FORCE_INLINE_TEMPLATE U32
1144 HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
1145 {
1146     size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
1147     ZSTD_memcpy(op, &dt[val].sequence, 1);
1148     if (dt[val].length==1) {
1149         BIT_skipBits(DStream, dt[val].nbBits);
1150     } else {
1151         if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
1152             BIT_skipBits(DStream, dt[val].nbBits);
1153             if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
1154                 /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
1155                 DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);
1156         }
1157     }
1158     return 1;
1159 }
1160 
1161 #define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
1162     ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
1163 
1164 #define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
1165     if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
1166         ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
1167 
1168 #define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
1169     if (MEM_64bits()) \
1170         ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
1171 
1172 HINT_INLINE size_t
1173 HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
1174                 const HUF_DEltX2* const dt, const U32 dtLog)
1175 {
1176     BYTE* const pStart = p;
1177 
1178     /* up to 8 symbols at a time */
1179     if ((size_t)(pEnd - p) >= sizeof(bitDPtr->bitContainer)) {
1180         if (dtLog <= 11 && MEM_64bits()) {
1181             /* up to 10 symbols at a time */
1182             while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-9)) {
1183                 HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
1184                 HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
1185                 HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
1186                 HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
1187                 HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
1188             }
1189         } else {
1190             /* up to 8 symbols at a time */
1191             while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) {
1192                 HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
1193                 HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
1194                 HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
1195                 HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
1196             }
1197         }
1198     } else {
1199         BIT_reloadDStream(bitDPtr);
1200     }
1201 
1202     /* closer to end : up to 2 symbols at a time */
1203     if ((size_t)(pEnd - p) >= 2) {
1204         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))
1205             HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
1206 
1207         while (p <= pEnd-2)
1208             HUF_DECODE_SYMBOLX2_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
1209     }
1210 
1211     if (p < pEnd)
1212         p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog);
1213 
1214     return p-pStart;
1215 }
1216 
1217 FORCE_INLINE_TEMPLATE size_t
1218 HUF_decompress1X2_usingDTable_internal_body(
1219           void* dst,  size_t dstSize,
1220     const void* cSrc, size_t cSrcSize,
1221     const HUF_DTable* DTable)
1222 {
1223     BIT_DStream_t bitD;
1224 
1225     /* Init */
1226     CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
1227 
1228     /* decode */
1229     {   BYTE* const ostart = (BYTE*) dst;
1230         BYTE* const oend = ostart + dstSize;
1231         const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */
1232         const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
1233         DTableDesc const dtd = HUF_getDTableDesc(DTable);
1234         HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);
1235     }
1236 
1237     /* check */
1238     if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
1239 
1240     /* decoded size */
1241     return dstSize;
1242 }
1243 FORCE_INLINE_TEMPLATE size_t
1244 HUF_decompress4X2_usingDTable_internal_body(
1245           void* dst,  size_t dstSize,
1246     const void* cSrc, size_t cSrcSize,
1247     const HUF_DTable* DTable)
1248 {
1249     if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
1250 
1251     {   const BYTE* const istart = (const BYTE*) cSrc;
1252         BYTE* const ostart = (BYTE*) dst;
1253         BYTE* const oend = ostart + dstSize;
1254         BYTE* const olimit = oend - (sizeof(size_t)-1);
1255         const void* const dtPtr = DTable+1;
1256         const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
1257 
1258         /* Init */
1259         BIT_DStream_t bitD1;
1260         BIT_DStream_t bitD2;
1261         BIT_DStream_t bitD3;
1262         BIT_DStream_t bitD4;
1263         size_t const length1 = MEM_readLE16(istart);
1264         size_t const length2 = MEM_readLE16(istart+2);
1265         size_t const length3 = MEM_readLE16(istart+4);
1266         size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
1267         const BYTE* const istart1 = istart + 6;  /* jumpTable */
1268         const BYTE* const istart2 = istart1 + length1;
1269         const BYTE* const istart3 = istart2 + length2;
1270         const BYTE* const istart4 = istart3 + length3;
1271         size_t const segmentSize = (dstSize+3) / 4;
1272         BYTE* const opStart2 = ostart + segmentSize;
1273         BYTE* const opStart3 = opStart2 + segmentSize;
1274         BYTE* const opStart4 = opStart3 + segmentSize;
1275         BYTE* op1 = ostart;
1276         BYTE* op2 = opStart2;
1277         BYTE* op3 = opStart3;
1278         BYTE* op4 = opStart4;
1279         U32 endSignal = 1;
1280         DTableDesc const dtd = HUF_getDTableDesc(DTable);
1281         U32 const dtLog = dtd.tableLog;
1282 
1283         if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
1284         if (opStart4 > oend) return ERROR(corruption_detected);      /* overflow */
1285         CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
1286         CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
1287         CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
1288         CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
1289 
1290         /* 16-32 symbols per loop (4-8 symbols per stream) */
1291         if ((size_t)(oend - op4) >= sizeof(size_t)) {
1292             for ( ; (endSignal) & (op4 < olimit); ) {
1293 #if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
1294                 HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
1295                 HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
1296                 HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
1297                 HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
1298                 HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
1299                 HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
1300                 HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
1301                 HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
1302                 endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
1303                 endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
1304                 HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
1305                 HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
1306                 HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
1307                 HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
1308                 HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
1309                 HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
1310                 HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
1311                 HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
1312                 endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
1313                 endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
1314 #else
1315                 HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
1316                 HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
1317                 HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
1318                 HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
1319                 HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
1320                 HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
1321                 HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
1322                 HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
1323                 HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
1324                 HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
1325                 HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
1326                 HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
1327                 HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
1328                 HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
1329                 HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
1330                 HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
1331                 endSignal = (U32)LIKELY((U32)
1332                             (BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished)
1333                         & (BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished)
1334                         & (BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished)
1335                         & (BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished));
1336 #endif
1337             }
1338         }
1339 
1340         /* check corruption */
1341         if (op1 > opStart2) return ERROR(corruption_detected);
1342         if (op2 > opStart3) return ERROR(corruption_detected);
1343         if (op3 > opStart4) return ERROR(corruption_detected);
1344         /* note : op4 already verified within main loop */
1345 
1346         /* finish bitStreams one by one */
1347         HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
1348         HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
1349         HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
1350         HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
1351 
1352         /* check */
1353         { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
1354           if (!endCheck) return ERROR(corruption_detected); }
1355 
1356         /* decoded size */
1357         return dstSize;
1358     }
1359 }
1360 
1361 #if HUF_NEED_BMI2_FUNCTION
1362 static BMI2_TARGET_ATTRIBUTE
1363 size_t HUF_decompress4X2_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,
1364                     size_t cSrcSize, HUF_DTable const* DTable) {
1365     return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
1366 }
1367 #endif
1368 
1369 #if HUF_NEED_DEFAULT_FUNCTION
1370 static
1371 size_t HUF_decompress4X2_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,
1372                     size_t cSrcSize, HUF_DTable const* DTable) {
1373     return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
1374 }
1375 #endif
1376 
1377 #if ZSTD_ENABLE_ASM_X86_64_BMI2
1378 
1379 HUF_ASM_DECL void HUF_decompress4X2_usingDTable_internal_bmi2_asm_loop(HUF_DecompressAsmArgs* args) ZSTDLIB_HIDDEN;
1380 
1381 static HUF_ASM_X86_64_BMI2_ATTRS size_t
1382 HUF_decompress4X2_usingDTable_internal_bmi2_asm(
1383           void* dst,  size_t dstSize,
1384     const void* cSrc, size_t cSrcSize,
1385     const HUF_DTable* DTable) {
1386     void const* dt = DTable + 1;
1387     const BYTE* const iend = (const BYTE*)cSrc + 6;
1388     BYTE* const oend = (BYTE*)dst + dstSize;
1389     HUF_DecompressAsmArgs args;
1390     {
1391         size_t const ret = HUF_DecompressAsmArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);
1392         FORWARD_IF_ERROR(ret, "Failed to init asm args");
1393         if (ret != 0)
1394             return HUF_decompress4X2_usingDTable_internal_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);
1395     }
1396 
1397     assert(args.ip[0] >= args.ilimit);
1398     HUF_decompress4X2_usingDTable_internal_bmi2_asm_loop(&args);
1399 
1400     /* note : op4 already verified within main loop */
1401     assert(args.ip[0] >= iend);
1402     assert(args.ip[1] >= iend);
1403     assert(args.ip[2] >= iend);
1404     assert(args.ip[3] >= iend);
1405     assert(args.op[3] <= oend);
1406     (void)iend;
1407 
1408     /* finish bitStreams one by one */
1409     {
1410         size_t const segmentSize = (dstSize+3) / 4;
1411         BYTE* segmentEnd = (BYTE*)dst;
1412         int i;
1413         for (i = 0; i < 4; ++i) {
1414             BIT_DStream_t bit;
1415             if (segmentSize <= (size_t)(oend - segmentEnd))
1416                 segmentEnd += segmentSize;
1417             else
1418                 segmentEnd = oend;
1419             FORWARD_IF_ERROR(HUF_initRemainingDStream(&bit, &args, i, segmentEnd), "corruption");
1420             args.op[i] += HUF_decodeStreamX2(args.op[i], &bit, segmentEnd, (HUF_DEltX2 const*)dt, HUF_DECODER_FAST_TABLELOG);
1421             if (args.op[i] != segmentEnd)
1422                 return ERROR(corruption_detected);
1423         }
1424     }
1425 
1426     /* decoded size */
1427     return dstSize;
1428 }
1429 #endif /* ZSTD_ENABLE_ASM_X86_64_BMI2 */
1430 
1431 static size_t HUF_decompress4X2_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,
1432                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)
1433 {
1434 #if DYNAMIC_BMI2
1435     if (bmi2) {
1436 # if ZSTD_ENABLE_ASM_X86_64_BMI2
1437         return HUF_decompress4X2_usingDTable_internal_bmi2_asm(dst, dstSize, cSrc, cSrcSize, DTable);
1438 # else
1439         return HUF_decompress4X2_usingDTable_internal_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);
1440 # endif
1441     }
1442 #else
1443     (void)bmi2;
1444 #endif
1445 
1446 #if ZSTD_ENABLE_ASM_X86_64_BMI2 && defined(__BMI2__)
1447     return HUF_decompress4X2_usingDTable_internal_bmi2_asm(dst, dstSize, cSrc, cSrcSize, DTable);
1448 #else
1449     return HUF_decompress4X2_usingDTable_internal_default(dst, dstSize, cSrc, cSrcSize, DTable);
1450 #endif
1451 }
1452 
1453 HUF_DGEN(HUF_decompress1X2_usingDTable_internal)
1454 
1455 size_t HUF_decompress1X2_usingDTable(
1456           void* dst,  size_t dstSize,
1457     const void* cSrc, size_t cSrcSize,
1458     const HUF_DTable* DTable)
1459 {
1460     DTableDesc dtd = HUF_getDTableDesc(DTable);
1461     if (dtd.tableType != 1) return ERROR(GENERIC);
1462     return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1463 }
1464 
1465 size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
1466                                    const void* cSrc, size_t cSrcSize,
1467                                    void* workSpace, size_t wkspSize)
1468 {
1469     const BYTE* ip = (const BYTE*) cSrc;
1470 
1471     size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
1472                                                workSpace, wkspSize);
1473     if (HUF_isError(hSize)) return hSize;
1474     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
1475     ip += hSize; cSrcSize -= hSize;
1476 
1477     return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
1478 }
1479 
1480 
1481 size_t HUF_decompress4X2_usingDTable(
1482           void* dst,  size_t dstSize,
1483     const void* cSrc, size_t cSrcSize,
1484     const HUF_DTable* DTable)
1485 {
1486     DTableDesc dtd = HUF_getDTableDesc(DTable);
1487     if (dtd.tableType != 1) return ERROR(GENERIC);
1488     return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1489 }
1490 
1491 static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
1492                                    const void* cSrc, size_t cSrcSize,
1493                                    void* workSpace, size_t wkspSize, int bmi2)
1494 {
1495     const BYTE* ip = (const BYTE*) cSrc;
1496 
1497     size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
1498                                          workSpace, wkspSize);
1499     if (HUF_isError(hSize)) return hSize;
1500     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
1501     ip += hSize; cSrcSize -= hSize;
1502 
1503     return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
1504 }
1505 
1506 size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
1507                                    const void* cSrc, size_t cSrcSize,
1508                                    void* workSpace, size_t wkspSize)
1509 {
1510     return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0);
1511 }
1512 
1513 
1514 #endif /* HUF_FORCE_DECOMPRESS_X1 */
1515 
1516 
1517 /* ***********************************/
1518 /* Universal decompression selectors */
1519 /* ***********************************/
1520 
1521 size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
1522                                     const void* cSrc, size_t cSrcSize,
1523                                     const HUF_DTable* DTable)
1524 {
1525     DTableDesc const dtd = HUF_getDTableDesc(DTable);
1526 #if defined(HUF_FORCE_DECOMPRESS_X1)
1527     (void)dtd;
1528     assert(dtd.tableType == 0);
1529     return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1530 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1531     (void)dtd;
1532     assert(dtd.tableType == 1);
1533     return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1534 #else
1535     return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
1536                            HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1537 #endif
1538 }
1539 
1540 size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
1541                                     const void* cSrc, size_t cSrcSize,
1542                                     const HUF_DTable* DTable)
1543 {
1544     DTableDesc const dtd = HUF_getDTableDesc(DTable);
1545 #if defined(HUF_FORCE_DECOMPRESS_X1)
1546     (void)dtd;
1547     assert(dtd.tableType == 0);
1548     return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1549 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1550     (void)dtd;
1551     assert(dtd.tableType == 1);
1552     return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1553 #else
1554     return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
1555                            HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
1556 #endif
1557 }
1558 
1559 
1560 #if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
1561 typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
1562 static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */] =
1563 {
1564     /* single, double, quad */
1565     {{0,0}, {1,1}},  /* Q==0 : impossible */
1566     {{0,0}, {1,1}},  /* Q==1 : impossible */
1567     {{ 150,216}, { 381,119}},   /* Q == 2 : 12-18% */
1568     {{ 170,205}, { 514,112}},   /* Q == 3 : 18-25% */
1569     {{ 177,199}, { 539,110}},   /* Q == 4 : 25-32% */
1570     {{ 197,194}, { 644,107}},   /* Q == 5 : 32-38% */
1571     {{ 221,192}, { 735,107}},   /* Q == 6 : 38-44% */
1572     {{ 256,189}, { 881,106}},   /* Q == 7 : 44-50% */
1573     {{ 359,188}, {1167,109}},   /* Q == 8 : 50-56% */
1574     {{ 582,187}, {1570,114}},   /* Q == 9 : 56-62% */
1575     {{ 688,187}, {1712,122}},   /* Q ==10 : 62-69% */
1576     {{ 825,186}, {1965,136}},   /* Q ==11 : 69-75% */
1577     {{ 976,185}, {2131,150}},   /* Q ==12 : 75-81% */
1578     {{1180,186}, {2070,175}},   /* Q ==13 : 81-87% */
1579     {{1377,185}, {1731,202}},   /* Q ==14 : 87-93% */
1580     {{1412,185}, {1695,202}},   /* Q ==15 : 93-99% */
1581 };
1582 #endif
1583 
1584 /* HUF_selectDecoder() :
1585  *  Tells which decoder is likely to decode faster,
1586  *  based on a set of pre-computed metrics.
1587  * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
1588  *  Assumption : 0 < dstSize <= 128 KB */
1589 U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
1590 {
1591     assert(dstSize > 0);
1592     assert(dstSize <= 128*1024);
1593 #if defined(HUF_FORCE_DECOMPRESS_X1)
1594     (void)dstSize;
1595     (void)cSrcSize;
1596     return 0;
1597 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1598     (void)dstSize;
1599     (void)cSrcSize;
1600     return 1;
1601 #else
1602     /* decoder timing evaluation */
1603     {   U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */
1604         U32 const D256 = (U32)(dstSize >> 8);
1605         U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
1606         U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
1607         DTime1 += DTime1 >> 5;  /* small advantage to algorithm using less memory, to reduce cache eviction */
1608         return DTime1 < DTime0;
1609     }
1610 #endif
1611 }
1612 
1613 
1614 size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
1615                                      size_t dstSize, const void* cSrc,
1616                                      size_t cSrcSize, void* workSpace,
1617                                      size_t wkspSize)
1618 {
1619     /* validation checks */
1620     if (dstSize == 0) return ERROR(dstSize_tooSmall);
1621     if (cSrcSize == 0) return ERROR(corruption_detected);
1622 
1623     {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1624 #if defined(HUF_FORCE_DECOMPRESS_X1)
1625         (void)algoNb;
1626         assert(algoNb == 0);
1627         return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
1628 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1629         (void)algoNb;
1630         assert(algoNb == 1);
1631         return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
1632 #else
1633         return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
1634                             cSrcSize, workSpace, wkspSize):
1635                         HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
1636 #endif
1637     }
1638 }
1639 
1640 size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
1641                                   const void* cSrc, size_t cSrcSize,
1642                                   void* workSpace, size_t wkspSize)
1643 {
1644     /* validation checks */
1645     if (dstSize == 0) return ERROR(dstSize_tooSmall);
1646     if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
1647     if (cSrcSize == dstSize) { ZSTD_memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
1648     if (cSrcSize == 1) { ZSTD_memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
1649 
1650     {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1651 #if defined(HUF_FORCE_DECOMPRESS_X1)
1652         (void)algoNb;
1653         assert(algoNb == 0);
1654         return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
1655                                 cSrcSize, workSpace, wkspSize);
1656 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1657         (void)algoNb;
1658         assert(algoNb == 1);
1659         return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
1660                                 cSrcSize, workSpace, wkspSize);
1661 #else
1662         return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
1663                                 cSrcSize, workSpace, wkspSize):
1664                         HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
1665                                 cSrcSize, workSpace, wkspSize);
1666 #endif
1667     }
1668 }
1669 
1670 
1671 size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
1672 {
1673     DTableDesc const dtd = HUF_getDTableDesc(DTable);
1674 #if defined(HUF_FORCE_DECOMPRESS_X1)
1675     (void)dtd;
1676     assert(dtd.tableType == 0);
1677     return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1678 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1679     (void)dtd;
1680     assert(dtd.tableType == 1);
1681     return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1682 #else
1683     return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
1684                            HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1685 #endif
1686 }
1687 
1688 #ifndef HUF_FORCE_DECOMPRESS_X2
1689 size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
1690 {
1691     const BYTE* ip = (const BYTE*) cSrc;
1692 
1693     size_t const hSize = HUF_readDTableX1_wksp_bmi2(dctx, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
1694     if (HUF_isError(hSize)) return hSize;
1695     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
1696     ip += hSize; cSrcSize -= hSize;
1697 
1698     return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
1699 }
1700 #endif
1701 
1702 size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
1703 {
1704     DTableDesc const dtd = HUF_getDTableDesc(DTable);
1705 #if defined(HUF_FORCE_DECOMPRESS_X1)
1706     (void)dtd;
1707     assert(dtd.tableType == 0);
1708     return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1709 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1710     (void)dtd;
1711     assert(dtd.tableType == 1);
1712     return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1713 #else
1714     return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
1715                            HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
1716 #endif
1717 }
1718 
1719 size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
1720 {
1721     /* validation checks */
1722     if (dstSize == 0) return ERROR(dstSize_tooSmall);
1723     if (cSrcSize == 0) return ERROR(corruption_detected);
1724 
1725     {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
1726 #if defined(HUF_FORCE_DECOMPRESS_X1)
1727         (void)algoNb;
1728         assert(algoNb == 0);
1729         return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
1730 #elif defined(HUF_FORCE_DECOMPRESS_X2)
1731         (void)algoNb;
1732         assert(algoNb == 1);
1733         return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
1734 #else
1735         return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) :
1736                         HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
1737 #endif
1738     }
1739 }
1740 
1741