Coverage Report

Created: 2026-11-13 07:26

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/work/libzstd-src/lib/common/bitstream.h
Line
Count
Source
1
/* ******************************************************************
2
 * bitstream
3
 * Part of FSE library
4
 * Copyright (c) Meta Platforms, Inc. and affiliates.
5
 *
6
 * You can contact the author at :
7
 * - 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
#ifndef BITSTREAM_H_MODULE
15
#define BITSTREAM_H_MODULE
16
17
/*
18
*  This API consists of small unitary functions, which must be inlined for best performance.
19
*  Since link-time-optimization is not available for all compilers,
20
*  these functions are defined into a .h to be included.
21
*/
22
23
/*-****************************************
24
*  Dependencies
25
******************************************/
26
#include "mem.h"            /* unaligned access routines */
27
#include "compiler.h"       /* UNLIKELY() */
28
#include "debug.h"          /* assert(), DEBUGLOG(), RAWLOG() */
29
#include "error_private.h"  /* error codes and messages */
30
#include "bits.h"           /* ZSTD_highbit32 */
31
32
/*=========================================
33
*  Target specific
34
=========================================*/
35
#ifndef ZSTD_NO_INTRINSICS
36
#  if (defined(__BMI__) || defined(__BMI2__)) && defined(__GNUC__)
37
#    include <immintrin.h>   /* support for bextr (experimental)/bzhi */
38
#  elif defined(__ICCARM__)
39
#    include <intrinsics.h>
40
#  endif
41
#endif
42
43
0
#define STREAM_ACCUMULATOR_MIN_32  25
44
0
#define STREAM_ACCUMULATOR_MIN_64  57
45
0
#define STREAM_ACCUMULATOR_MIN    ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))
46
47
48
/*-******************************************
49
*  bitStream encoding API (write forward)
50
********************************************/
51
typedef size_t BitContainerType;
52
/* bitStream can mix input from multiple sources.
53
 * A critical property of these streams is that they encode and decode in **reverse** direction.
54
 * So the first bit sequence you add will be the last to be read, like a LIFO stack.
55
 */
56
typedef struct {
57
    BitContainerType bitContainer;
58
    unsigned bitPos;
59
    char*  startPtr;
60
    char*  ptr;
61
    char*  endPtr;
62
} BIT_CStream_t;
63
64
MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);
65
MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, BitContainerType value, unsigned nbBits);
66
MEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC);
67
MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
68
69
/* Start with initCStream, providing the size of buffer to write into.
70
*  bitStream will never write outside of this buffer.
71
*  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
72
*
73
*  bits are first added to a local register.
74
*  Local register is BitContainerType, 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
75
*  Writing data into memory is an explicit operation, performed by the flushBits function.
76
*  Hence keep track how many bits are potentially stored into local register to avoid register overflow.
77
*  After a flushBits, a maximum of 7 bits might still be stored into local register.
78
*
79
*  Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers.
80
*
81
*  Last operation is to close the bitStream.
82
*  The function returns the final size of CStream in bytes.
83
*  If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
84
*/
85
86
87
/*-********************************************
88
*  bitStream decoding API (read backward)
89
**********************************************/
90
typedef struct {
91
    BitContainerType bitContainer;
92
    unsigned bitsConsumed;
93
    const char* ptr;
94
    const char* start;
95
    const char* limitPtr;
96
} BIT_DStream_t;
97
98
typedef enum { BIT_DStream_unfinished = 0,  /* fully refilled */
99
               BIT_DStream_endOfBuffer = 1, /* still some bits left in bitstream */
100
               BIT_DStream_completed = 2,   /* bitstream entirely consumed, bit-exact */
101
               BIT_DStream_overflow = 3     /* user requested more bits than present in bitstream */
102
    } BIT_DStream_status;  /* result of BIT_reloadDStream() */
103
104
MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
105
MEM_STATIC BitContainerType BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
106
MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
107
MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
108
109
110
/* Start by invoking BIT_initDStream().
111
*  A chunk of the bitStream is then stored into a local register.
112
*  Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (BitContainerType).
113
*  You can then retrieve bitFields stored into the local register, **in reverse order**.
114
*  Local register is explicitly reloaded from memory by the BIT_reloadDStream() method.
115
*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
116
*  Otherwise, it can be less than that, so proceed accordingly.
117
*  Checking if DStream has reached its end can be performed with BIT_endOfDStream().
118
*/
119
120
121
/*-****************************************
122
*  unsafe API
123
******************************************/
124
MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, BitContainerType value, unsigned nbBits);
125
/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */
126
127
MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
128
/* unsafe version; does not check buffer overflow */
129
130
MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
131
/* faster, but works only if nbBits >= 1 */
132
133
/*=====    Local Constants   =====*/
134
static const unsigned BIT_mask[] = {
135
    0,          1,         3,         7,         0xF,       0x1F,
136
    0x3F,       0x7F,      0xFF,      0x1FF,     0x3FF,     0x7FF,
137
    0xFFF,      0x1FFF,    0x3FFF,    0x7FFF,    0xFFFF,    0x1FFFF,
138
    0x3FFFF,    0x7FFFF,   0xFFFFF,   0x1FFFFF,  0x3FFFFF,  0x7FFFFF,
139
    0xFFFFFF,   0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF,
140
    0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */
141
#define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0]))
142
143
/*-**************************************************************
144
*  bitStream encoding
145
****************************************************************/
146
/*! BIT_initCStream() :
147
 *  `dstCapacity` must be > sizeof(size_t)
148
 *  @return : 0 if success,
149
 *            otherwise an error code (can be tested using ERR_isError()) */
150
MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
151
                                  void* startPtr, size_t dstCapacity)
152
0
{
153
0
    bitC->bitContainer = 0;
154
0
    bitC->bitPos = 0;
155
0
    bitC->startPtr = (char*)startPtr;
156
0
    bitC->ptr = bitC->startPtr;
157
0
    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer);
158
0
    if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall);
159
0
    return 0;
160
0
}
Unexecuted instantiation: zstd_common.c:BIT_initCStream
Unexecuted instantiation: zstd_compress.c:BIT_initCStream
Unexecuted instantiation: zstd_compress_literals.c:BIT_initCStream
Unexecuted instantiation: zstd_compress_sequences.c:BIT_initCStream
Unexecuted instantiation: zstd_compress_superblock.c:BIT_initCStream
Unexecuted instantiation: zstd_double_fast.c:BIT_initCStream
Unexecuted instantiation: zstd_fast.c:BIT_initCStream
Unexecuted instantiation: zstd_lazy.c:BIT_initCStream
Unexecuted instantiation: zstd_ldm.c:BIT_initCStream
Unexecuted instantiation: zstd_opt.c:BIT_initCStream
Unexecuted instantiation: zstd_preSplit.c:BIT_initCStream
Unexecuted instantiation: zstd_decompress.c:BIT_initCStream
Unexecuted instantiation: zstd_decompress_block.c:BIT_initCStream
Unexecuted instantiation: entropy_common.c:BIT_initCStream
Unexecuted instantiation: fse_decompress.c:BIT_initCStream
Unexecuted instantiation: fse_compress.c:BIT_initCStream
Unexecuted instantiation: huf_compress.c:BIT_initCStream
Unexecuted instantiation: huf_decompress.c:BIT_initCStream
Unexecuted instantiation: zstd_ddict.c:BIT_initCStream
161
162
FORCE_INLINE_TEMPLATE BitContainerType BIT_getLowerBits(BitContainerType bitContainer, U32 const nbBits)
163
0
{
164
#if STATIC_BMI2 && !defined(ZSTD_NO_INTRINSICS)
165
#  if (defined(__x86_64__) || defined(_M_X64)) && !defined(__ILP32__)
166
    return _bzhi_u64(bitContainer, nbBits);
167
#  else
168
    DEBUG_STATIC_ASSERT(sizeof(bitContainer) == sizeof(U32));
169
    return _bzhi_u32(bitContainer, nbBits);
170
#  endif
171
#else
172
0
    assert(nbBits < BIT_MASK_SIZE);
173
0
    return bitContainer & BIT_mask[nbBits];
174
0
#endif
175
0
}
Unexecuted instantiation: zstd_common.c:BIT_getLowerBits
Unexecuted instantiation: zstd_compress.c:BIT_getLowerBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_getLowerBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_getLowerBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_getLowerBits
Unexecuted instantiation: zstd_double_fast.c:BIT_getLowerBits
Unexecuted instantiation: zstd_fast.c:BIT_getLowerBits
Unexecuted instantiation: zstd_lazy.c:BIT_getLowerBits
Unexecuted instantiation: zstd_ldm.c:BIT_getLowerBits
Unexecuted instantiation: zstd_opt.c:BIT_getLowerBits
Unexecuted instantiation: zstd_preSplit.c:BIT_getLowerBits
Unexecuted instantiation: zstd_decompress.c:BIT_getLowerBits
Unexecuted instantiation: zstd_decompress_block.c:BIT_getLowerBits
Unexecuted instantiation: entropy_common.c:BIT_getLowerBits
Unexecuted instantiation: fse_decompress.c:BIT_getLowerBits
Unexecuted instantiation: fse_compress.c:BIT_getLowerBits
Unexecuted instantiation: huf_compress.c:BIT_getLowerBits
Unexecuted instantiation: huf_decompress.c:BIT_getLowerBits
Unexecuted instantiation: zstd_ddict.c:BIT_getLowerBits
176
177
/*! BIT_addBits() :
178
 *  can add up to 31 bits into `bitC`.
179
 *  Note : does not check for register overflow ! */
180
MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
181
                            BitContainerType value, unsigned nbBits)
182
0
{
183
0
    DEBUG_STATIC_ASSERT(BIT_MASK_SIZE == 32);
184
0
    assert(nbBits < BIT_MASK_SIZE);
185
0
    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
186
0
    bitC->bitContainer |= BIT_getLowerBits(value, nbBits) << bitC->bitPos;
187
0
    bitC->bitPos += nbBits;
188
0
}
Unexecuted instantiation: zstd_common.c:BIT_addBits
Unexecuted instantiation: zstd_compress.c:BIT_addBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_addBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_addBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_addBits
Unexecuted instantiation: zstd_double_fast.c:BIT_addBits
Unexecuted instantiation: zstd_fast.c:BIT_addBits
Unexecuted instantiation: zstd_lazy.c:BIT_addBits
Unexecuted instantiation: zstd_ldm.c:BIT_addBits
Unexecuted instantiation: zstd_opt.c:BIT_addBits
Unexecuted instantiation: zstd_preSplit.c:BIT_addBits
Unexecuted instantiation: zstd_decompress.c:BIT_addBits
Unexecuted instantiation: zstd_decompress_block.c:BIT_addBits
Unexecuted instantiation: entropy_common.c:BIT_addBits
Unexecuted instantiation: fse_decompress.c:BIT_addBits
Unexecuted instantiation: fse_compress.c:BIT_addBits
Unexecuted instantiation: huf_compress.c:BIT_addBits
Unexecuted instantiation: huf_decompress.c:BIT_addBits
Unexecuted instantiation: zstd_ddict.c:BIT_addBits
189
190
/*! BIT_addBitsFast() :
191
 *  works only if `value` is _clean_,
192
 *  meaning all high bits above nbBits are 0 */
193
MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC,
194
                                BitContainerType value, unsigned nbBits)
195
0
{
196
0
    assert((value>>nbBits) == 0);
197
0
    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
198
0
    bitC->bitContainer |= value << bitC->bitPos;
199
0
    bitC->bitPos += nbBits;
200
0
}
Unexecuted instantiation: zstd_common.c:BIT_addBitsFast
Unexecuted instantiation: zstd_compress.c:BIT_addBitsFast
Unexecuted instantiation: zstd_compress_literals.c:BIT_addBitsFast
Unexecuted instantiation: zstd_compress_sequences.c:BIT_addBitsFast
Unexecuted instantiation: zstd_compress_superblock.c:BIT_addBitsFast
Unexecuted instantiation: zstd_double_fast.c:BIT_addBitsFast
Unexecuted instantiation: zstd_fast.c:BIT_addBitsFast
Unexecuted instantiation: zstd_lazy.c:BIT_addBitsFast
Unexecuted instantiation: zstd_ldm.c:BIT_addBitsFast
Unexecuted instantiation: zstd_opt.c:BIT_addBitsFast
Unexecuted instantiation: zstd_preSplit.c:BIT_addBitsFast
Unexecuted instantiation: zstd_decompress.c:BIT_addBitsFast
Unexecuted instantiation: zstd_decompress_block.c:BIT_addBitsFast
Unexecuted instantiation: entropy_common.c:BIT_addBitsFast
Unexecuted instantiation: fse_decompress.c:BIT_addBitsFast
Unexecuted instantiation: fse_compress.c:BIT_addBitsFast
Unexecuted instantiation: huf_compress.c:BIT_addBitsFast
Unexecuted instantiation: huf_decompress.c:BIT_addBitsFast
Unexecuted instantiation: zstd_ddict.c:BIT_addBitsFast
201
202
/*! BIT_flushBitsFast() :
203
 *  assumption : bitContainer has not overflowed
204
 *  unsafe version; does not check buffer overflow */
205
MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
206
0
{
207
0
    size_t const nbBytes = bitC->bitPos >> 3;
208
0
    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
209
0
    assert(bitC->ptr <= bitC->endPtr);
210
0
    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
211
0
    bitC->ptr += nbBytes;
212
0
    bitC->bitPos &= 7;
213
0
    bitC->bitContainer >>= nbBytes*8;
214
0
}
Unexecuted instantiation: zstd_common.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_compress.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_compress_literals.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_compress_sequences.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_compress_superblock.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_double_fast.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_fast.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_lazy.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_ldm.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_opt.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_preSplit.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_decompress.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_decompress_block.c:BIT_flushBitsFast
Unexecuted instantiation: entropy_common.c:BIT_flushBitsFast
Unexecuted instantiation: fse_decompress.c:BIT_flushBitsFast
Unexecuted instantiation: fse_compress.c:BIT_flushBitsFast
Unexecuted instantiation: huf_compress.c:BIT_flushBitsFast
Unexecuted instantiation: huf_decompress.c:BIT_flushBitsFast
Unexecuted instantiation: zstd_ddict.c:BIT_flushBitsFast
215
216
/*! BIT_flushBits() :
217
 *  assumption : bitContainer has not overflowed
218
 *  safe version; check for buffer overflow, and prevents it.
219
 *  note : does not signal buffer overflow.
220
 *  overflow will be revealed later on using BIT_closeCStream() */
221
MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
222
0
{
223
0
    size_t const nbBytes = bitC->bitPos >> 3;
224
0
    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
225
0
    assert(bitC->ptr <= bitC->endPtr);
226
0
    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
227
0
    bitC->ptr += nbBytes;
228
0
    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
229
0
    bitC->bitPos &= 7;
230
0
    bitC->bitContainer >>= nbBytes*8;
231
0
}
Unexecuted instantiation: zstd_common.c:BIT_flushBits
Unexecuted instantiation: zstd_compress.c:BIT_flushBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_flushBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_flushBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_flushBits
Unexecuted instantiation: zstd_double_fast.c:BIT_flushBits
Unexecuted instantiation: zstd_fast.c:BIT_flushBits
Unexecuted instantiation: zstd_lazy.c:BIT_flushBits
Unexecuted instantiation: zstd_ldm.c:BIT_flushBits
Unexecuted instantiation: zstd_opt.c:BIT_flushBits
Unexecuted instantiation: zstd_preSplit.c:BIT_flushBits
Unexecuted instantiation: zstd_decompress.c:BIT_flushBits
Unexecuted instantiation: zstd_decompress_block.c:BIT_flushBits
Unexecuted instantiation: entropy_common.c:BIT_flushBits
Unexecuted instantiation: fse_decompress.c:BIT_flushBits
Unexecuted instantiation: fse_compress.c:BIT_flushBits
Unexecuted instantiation: huf_compress.c:BIT_flushBits
Unexecuted instantiation: huf_decompress.c:BIT_flushBits
Unexecuted instantiation: zstd_ddict.c:BIT_flushBits
232
233
/*! BIT_closeCStream() :
234
 *  @return : size of CStream, in bytes,
235
 *            or 0 if it could not fit into dstBuffer */
236
MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
237
0
{
238
0
    BIT_addBitsFast(bitC, 1, 1);   /* endMark */
239
0
    BIT_flushBits(bitC);
240
0
    if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */
241
0
    return (size_t)(bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
242
0
}
Unexecuted instantiation: zstd_common.c:BIT_closeCStream
Unexecuted instantiation: zstd_compress.c:BIT_closeCStream
Unexecuted instantiation: zstd_compress_literals.c:BIT_closeCStream
Unexecuted instantiation: zstd_compress_sequences.c:BIT_closeCStream
Unexecuted instantiation: zstd_compress_superblock.c:BIT_closeCStream
Unexecuted instantiation: zstd_double_fast.c:BIT_closeCStream
Unexecuted instantiation: zstd_fast.c:BIT_closeCStream
Unexecuted instantiation: zstd_lazy.c:BIT_closeCStream
Unexecuted instantiation: zstd_ldm.c:BIT_closeCStream
Unexecuted instantiation: zstd_opt.c:BIT_closeCStream
Unexecuted instantiation: zstd_preSplit.c:BIT_closeCStream
Unexecuted instantiation: zstd_decompress.c:BIT_closeCStream
Unexecuted instantiation: zstd_decompress_block.c:BIT_closeCStream
Unexecuted instantiation: entropy_common.c:BIT_closeCStream
Unexecuted instantiation: fse_decompress.c:BIT_closeCStream
Unexecuted instantiation: fse_compress.c:BIT_closeCStream
Unexecuted instantiation: huf_compress.c:BIT_closeCStream
Unexecuted instantiation: huf_decompress.c:BIT_closeCStream
Unexecuted instantiation: zstd_ddict.c:BIT_closeCStream
243
244
245
/*-********************************************************
246
*  bitStream decoding
247
**********************************************************/
248
/*! BIT_initDStream() :
249
 *  Initialize a BIT_DStream_t.
250
 * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
251
 * `srcSize` must be the *exact* size of the bitStream, in bytes.
252
 * @return : size of stream (== srcSize), or an errorCode if a problem is detected
253
 */
254
MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
255
9.66k
{
256
9.66k
    if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
257
258
9.61k
    bitD->start = (const char*)srcBuffer;
259
9.61k
    bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
260
261
9.61k
    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
262
5.75k
        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
263
5.75k
        bitD->bitContainer = MEM_readLEST(bitD->ptr);
264
5.75k
        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
265
5.75k
          bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
266
5.75k
          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
267
5.75k
    } else {
268
3.86k
        bitD->ptr   = bitD->start;
269
3.86k
        bitD->bitContainer = *(const BYTE*)(bitD->start);
270
3.86k
        switch(srcSize)
271
3.86k
        {
272
208
        case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
273
208
                ZSTD_FALLTHROUGH;
274
275
644
        case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
276
644
                ZSTD_FALLTHROUGH;
277
278
1.16k
        case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
279
1.16k
                ZSTD_FALLTHROUGH;
280
281
2.04k
        case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24;
282
2.04k
                ZSTD_FALLTHROUGH;
283
284
2.76k
        case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16;
285
2.76k
                ZSTD_FALLTHROUGH;
286
287
3.36k
        case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) <<  8;
288
3.36k
                ZSTD_FALLTHROUGH;
289
290
3.86k
        default: break;
291
3.86k
        }
292
3.86k
        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
293
3.86k
            bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;
294
3.86k
            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
295
3.86k
        }
296
3.79k
        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
297
3.79k
    }
298
299
9.49k
    return srcSize;
300
9.61k
}
Unexecuted instantiation: zstd_common.c:BIT_initDStream
Unexecuted instantiation: zstd_compress.c:BIT_initDStream
Unexecuted instantiation: zstd_compress_literals.c:BIT_initDStream
Unexecuted instantiation: zstd_compress_sequences.c:BIT_initDStream
Unexecuted instantiation: zstd_compress_superblock.c:BIT_initDStream
Unexecuted instantiation: zstd_double_fast.c:BIT_initDStream
Unexecuted instantiation: zstd_fast.c:BIT_initDStream
Unexecuted instantiation: zstd_lazy.c:BIT_initDStream
Unexecuted instantiation: zstd_ldm.c:BIT_initDStream
Unexecuted instantiation: zstd_opt.c:BIT_initDStream
Unexecuted instantiation: zstd_preSplit.c:BIT_initDStream
Unexecuted instantiation: zstd_decompress.c:BIT_initDStream
zstd_decompress_block.c:BIT_initDStream
Line
Count
Source
255
9.08k
{
256
9.08k
    if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
257
258
9.06k
    bitD->start = (const char*)srcBuffer;
259
9.06k
    bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
260
261
9.06k
    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
262
5.41k
        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
263
5.41k
        bitD->bitContainer = MEM_readLEST(bitD->ptr);
264
5.41k
        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
265
5.41k
          bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
266
5.41k
          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
267
5.41k
    } else {
268
3.65k
        bitD->ptr   = bitD->start;
269
3.65k
        bitD->bitContainer = *(const BYTE*)(bitD->start);
270
3.65k
        switch(srcSize)
271
3.65k
        {
272
186
        case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
273
186
                ZSTD_FALLTHROUGH;
274
275
582
        case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
276
582
                ZSTD_FALLTHROUGH;
277
278
1.08k
        case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
279
1.08k
                ZSTD_FALLTHROUGH;
280
281
1.92k
        case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24;
282
1.92k
                ZSTD_FALLTHROUGH;
283
284
2.61k
        case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16;
285
2.61k
                ZSTD_FALLTHROUGH;
286
287
3.17k
        case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) <<  8;
288
3.17k
                ZSTD_FALLTHROUGH;
289
290
3.65k
        default: break;
291
3.65k
        }
292
3.65k
        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
293
3.65k
            bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;
294
3.65k
            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
295
3.65k
        }
296
3.62k
        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
297
3.62k
    }
298
299
9.01k
    return srcSize;
300
9.06k
}
Unexecuted instantiation: entropy_common.c:BIT_initDStream
fse_decompress.c:BIT_initDStream
Line
Count
Source
255
471
{
256
471
    if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
257
258
458
    bitD->start = (const char*)srcBuffer;
259
458
    bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
260
261
458
    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
262
293
        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
263
293
        bitD->bitContainer = MEM_readLEST(bitD->ptr);
264
293
        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
265
293
          bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
266
293
          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
267
293
    } else {
268
165
        bitD->ptr   = bitD->start;
269
165
        bitD->bitContainer = *(const BYTE*)(bitD->start);
270
165
        switch(srcSize)
271
165
        {
272
18
        case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
273
18
                ZSTD_FALLTHROUGH;
274
275
53
        case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
276
53
                ZSTD_FALLTHROUGH;
277
278
74
        case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
279
74
                ZSTD_FALLTHROUGH;
280
281
102
        case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24;
282
102
                ZSTD_FALLTHROUGH;
283
284
133
        case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16;
285
133
                ZSTD_FALLTHROUGH;
286
287
149
        case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) <<  8;
288
149
                ZSTD_FALLTHROUGH;
289
290
165
        default: break;
291
165
        }
292
165
        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
293
165
            bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;
294
165
            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
295
165
        }
296
134
        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
297
134
    }
298
299
409
    return srcSize;
300
458
}
Unexecuted instantiation: fse_compress.c:BIT_initDStream
Unexecuted instantiation: huf_compress.c:BIT_initDStream
huf_decompress.c:BIT_initDStream
Line
Count
Source
255
105
{
256
105
    if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
257
258
94
    bitD->start = (const char*)srcBuffer;
259
94
    bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
260
261
94
    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
262
46
        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
263
46
        bitD->bitContainer = MEM_readLEST(bitD->ptr);
264
46
        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
265
46
          bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
266
46
          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
267
48
    } else {
268
48
        bitD->ptr   = bitD->start;
269
48
        bitD->bitContainer = *(const BYTE*)(bitD->start);
270
48
        switch(srcSize)
271
48
        {
272
4
        case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
273
4
                ZSTD_FALLTHROUGH;
274
275
9
        case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
276
9
                ZSTD_FALLTHROUGH;
277
278
12
        case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
279
12
                ZSTD_FALLTHROUGH;
280
281
16
        case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24;
282
16
                ZSTD_FALLTHROUGH;
283
284
18
        case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16;
285
18
                ZSTD_FALLTHROUGH;
286
287
40
        case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) <<  8;
288
40
                ZSTD_FALLTHROUGH;
289
290
48
        default: break;
291
48
        }
292
48
        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
293
48
            bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;
294
48
            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
295
48
        }
296
38
        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
297
38
    }
298
299
77
    return srcSize;
300
94
}
Unexecuted instantiation: zstd_ddict.c:BIT_initDStream
301
302
FORCE_INLINE_TEMPLATE BitContainerType BIT_getUpperBits(BitContainerType bitContainer, U32 const start)
303
0
{
304
0
    return bitContainer >> start;
305
0
}
Unexecuted instantiation: zstd_common.c:BIT_getUpperBits
Unexecuted instantiation: zstd_compress.c:BIT_getUpperBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_getUpperBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_getUpperBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_getUpperBits
Unexecuted instantiation: zstd_double_fast.c:BIT_getUpperBits
Unexecuted instantiation: zstd_fast.c:BIT_getUpperBits
Unexecuted instantiation: zstd_lazy.c:BIT_getUpperBits
Unexecuted instantiation: zstd_ldm.c:BIT_getUpperBits
Unexecuted instantiation: zstd_opt.c:BIT_getUpperBits
Unexecuted instantiation: zstd_preSplit.c:BIT_getUpperBits
Unexecuted instantiation: zstd_decompress.c:BIT_getUpperBits
Unexecuted instantiation: zstd_decompress_block.c:BIT_getUpperBits
Unexecuted instantiation: entropy_common.c:BIT_getUpperBits
Unexecuted instantiation: fse_decompress.c:BIT_getUpperBits
Unexecuted instantiation: fse_compress.c:BIT_getUpperBits
Unexecuted instantiation: huf_compress.c:BIT_getUpperBits
Unexecuted instantiation: huf_decompress.c:BIT_getUpperBits
Unexecuted instantiation: zstd_ddict.c:BIT_getUpperBits
306
307
FORCE_INLINE_TEMPLATE BitContainerType BIT_getMiddleBits(BitContainerType bitContainer, U32 const start, U32 const nbBits)
308
32.4M
{
309
32.4M
    U32 const regMask = sizeof(bitContainer)*8 - 1;
310
    /* if start > regMask, bitstream is corrupted, and result is undefined */
311
32.4M
    assert(nbBits < BIT_MASK_SIZE);
312
    /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better
313
     * than accessing memory. When bmi2 instruction is not present, we consider
314
     * such cpus old (pre-Haswell, 2013) and their performance is not of that
315
     * importance.
316
     */
317
32.4M
#if defined(__x86_64__) || defined(_M_X64)
318
32.4M
    return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);
319
#else
320
    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
321
#endif
322
32.4M
}
Unexecuted instantiation: zstd_common.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_compress.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_double_fast.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_fast.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_lazy.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_ldm.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_opt.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_preSplit.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_decompress.c:BIT_getMiddleBits
zstd_decompress_block.c:BIT_getMiddleBits
Line
Count
Source
308
32.4M
{
309
32.4M
    U32 const regMask = sizeof(bitContainer)*8 - 1;
310
    /* if start > regMask, bitstream is corrupted, and result is undefined */
311
32.4M
    assert(nbBits < BIT_MASK_SIZE);
312
    /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better
313
     * than accessing memory. When bmi2 instruction is not present, we consider
314
     * such cpus old (pre-Haswell, 2013) and their performance is not of that
315
     * importance.
316
     */
317
32.4M
#if defined(__x86_64__) || defined(_M_X64)
318
32.4M
    return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);
319
#else
320
    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
321
#endif
322
32.4M
}
Unexecuted instantiation: entropy_common.c:BIT_getMiddleBits
fse_decompress.c:BIT_getMiddleBits
Line
Count
Source
308
20.9k
{
309
20.9k
    U32 const regMask = sizeof(bitContainer)*8 - 1;
310
    /* if start > regMask, bitstream is corrupted, and result is undefined */
311
20.9k
    assert(nbBits < BIT_MASK_SIZE);
312
    /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better
313
     * than accessing memory. When bmi2 instruction is not present, we consider
314
     * such cpus old (pre-Haswell, 2013) and their performance is not of that
315
     * importance.
316
     */
317
20.9k
#if defined(__x86_64__) || defined(_M_X64)
318
20.9k
    return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);
319
#else
320
    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
321
#endif
322
20.9k
}
Unexecuted instantiation: fse_compress.c:BIT_getMiddleBits
Unexecuted instantiation: huf_compress.c:BIT_getMiddleBits
Unexecuted instantiation: huf_decompress.c:BIT_getMiddleBits
Unexecuted instantiation: zstd_ddict.c:BIT_getMiddleBits
323
324
/*! BIT_lookBits() :
325
 *  Provides next n bits from local register.
326
 *  local register is not modified.
327
 *  On 32-bits, maxNbBits==24.
328
 *  On 64-bits, maxNbBits==56.
329
 * @return : value extracted */
330
FORCE_INLINE_TEMPLATE BitContainerType BIT_lookBits(const BIT_DStream_t*  bitD, U32 nbBits)
331
32.4M
{
332
    /* arbitrate between double-shift and shift+mask */
333
32.4M
#if 1
334
    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
335
     * bitstream is likely corrupted, and result is undefined */
336
32.4M
    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
337
#else
338
    /* this code path is slower on my os-x laptop */
339
    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
340
    return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
341
#endif
342
32.4M
}
Unexecuted instantiation: zstd_common.c:BIT_lookBits
Unexecuted instantiation: zstd_compress.c:BIT_lookBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_lookBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_lookBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_lookBits
Unexecuted instantiation: zstd_double_fast.c:BIT_lookBits
Unexecuted instantiation: zstd_fast.c:BIT_lookBits
Unexecuted instantiation: zstd_lazy.c:BIT_lookBits
Unexecuted instantiation: zstd_ldm.c:BIT_lookBits
Unexecuted instantiation: zstd_opt.c:BIT_lookBits
Unexecuted instantiation: zstd_preSplit.c:BIT_lookBits
Unexecuted instantiation: zstd_decompress.c:BIT_lookBits
zstd_decompress_block.c:BIT_lookBits
Line
Count
Source
331
32.4M
{
332
    /* arbitrate between double-shift and shift+mask */
333
32.4M
#if 1
334
    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
335
     * bitstream is likely corrupted, and result is undefined */
336
32.4M
    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
337
#else
338
    /* this code path is slower on my os-x laptop */
339
    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
340
    return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
341
#endif
342
32.4M
}
Unexecuted instantiation: entropy_common.c:BIT_lookBits
fse_decompress.c:BIT_lookBits
Line
Count
Source
331
20.9k
{
332
    /* arbitrate between double-shift and shift+mask */
333
20.9k
#if 1
334
    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
335
     * bitstream is likely corrupted, and result is undefined */
336
20.9k
    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
337
#else
338
    /* this code path is slower on my os-x laptop */
339
    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
340
    return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
341
#endif
342
20.9k
}
Unexecuted instantiation: fse_compress.c:BIT_lookBits
Unexecuted instantiation: huf_compress.c:BIT_lookBits
Unexecuted instantiation: huf_decompress.c:BIT_lookBits
Unexecuted instantiation: zstd_ddict.c:BIT_lookBits
343
344
/*! BIT_lookBitsFast() :
345
 *  unsafe version; only works if nbBits >= 1 */
346
MEM_STATIC BitContainerType BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
347
7.63M
{
348
7.63M
    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
349
7.63M
    assert(nbBits >= 1);
350
7.63M
    return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
351
7.63M
}
Unexecuted instantiation: zstd_common.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_compress.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_compress_literals.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_compress_sequences.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_compress_superblock.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_double_fast.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_fast.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_lazy.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_ldm.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_opt.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_preSplit.c:BIT_lookBitsFast
Unexecuted instantiation: zstd_decompress.c:BIT_lookBitsFast
zstd_decompress_block.c:BIT_lookBitsFast
Line
Count
Source
347
7.61M
{
348
7.61M
    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
349
7.61M
    assert(nbBits >= 1);
350
7.61M
    return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
351
7.61M
}
Unexecuted instantiation: entropy_common.c:BIT_lookBitsFast
fse_decompress.c:BIT_lookBitsFast
Line
Count
Source
347
7.48k
{
348
7.48k
    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
349
7.48k
    assert(nbBits >= 1);
350
7.48k
    return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
351
7.48k
}
Unexecuted instantiation: fse_compress.c:BIT_lookBitsFast
Unexecuted instantiation: huf_compress.c:BIT_lookBitsFast
huf_decompress.c:BIT_lookBitsFast
Line
Count
Source
347
14.2k
{
348
14.2k
    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
349
14.2k
    assert(nbBits >= 1);
350
14.2k
    return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
351
14.2k
}
Unexecuted instantiation: zstd_ddict.c:BIT_lookBitsFast
352
353
FORCE_INLINE_TEMPLATE void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
354
40.1M
{
355
40.1M
    bitD->bitsConsumed += nbBits;
356
40.1M
}
Unexecuted instantiation: zstd_common.c:BIT_skipBits
Unexecuted instantiation: zstd_compress.c:BIT_skipBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_skipBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_skipBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_skipBits
Unexecuted instantiation: zstd_double_fast.c:BIT_skipBits
Unexecuted instantiation: zstd_fast.c:BIT_skipBits
Unexecuted instantiation: zstd_lazy.c:BIT_skipBits
Unexecuted instantiation: zstd_ldm.c:BIT_skipBits
Unexecuted instantiation: zstd_opt.c:BIT_skipBits
Unexecuted instantiation: zstd_preSplit.c:BIT_skipBits
Unexecuted instantiation: zstd_decompress.c:BIT_skipBits
zstd_decompress_block.c:BIT_skipBits
Line
Count
Source
354
40.0M
{
355
40.0M
    bitD->bitsConsumed += nbBits;
356
40.0M
}
Unexecuted instantiation: entropy_common.c:BIT_skipBits
fse_decompress.c:BIT_skipBits
Line
Count
Source
354
28.4k
{
355
28.4k
    bitD->bitsConsumed += nbBits;
356
28.4k
}
Unexecuted instantiation: fse_compress.c:BIT_skipBits
Unexecuted instantiation: huf_compress.c:BIT_skipBits
huf_decompress.c:BIT_skipBits
Line
Count
Source
354
14.2k
{
355
14.2k
    bitD->bitsConsumed += nbBits;
356
14.2k
}
Unexecuted instantiation: zstd_ddict.c:BIT_skipBits
357
358
/*! BIT_readBits() :
359
 *  Read (consume) next n bits from local register and update.
360
 *  Pay attention to not read more than nbBits contained into local register.
361
 * @return : extracted value. */
362
FORCE_INLINE_TEMPLATE BitContainerType BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
363
32.4M
{
364
32.4M
    BitContainerType const value = BIT_lookBits(bitD, nbBits);
365
32.4M
    BIT_skipBits(bitD, nbBits);
366
32.4M
    return value;
367
32.4M
}
Unexecuted instantiation: zstd_common.c:BIT_readBits
Unexecuted instantiation: zstd_compress.c:BIT_readBits
Unexecuted instantiation: zstd_compress_literals.c:BIT_readBits
Unexecuted instantiation: zstd_compress_sequences.c:BIT_readBits
Unexecuted instantiation: zstd_compress_superblock.c:BIT_readBits
Unexecuted instantiation: zstd_double_fast.c:BIT_readBits
Unexecuted instantiation: zstd_fast.c:BIT_readBits
Unexecuted instantiation: zstd_lazy.c:BIT_readBits
Unexecuted instantiation: zstd_ldm.c:BIT_readBits
Unexecuted instantiation: zstd_opt.c:BIT_readBits
Unexecuted instantiation: zstd_preSplit.c:BIT_readBits
Unexecuted instantiation: zstd_decompress.c:BIT_readBits
zstd_decompress_block.c:BIT_readBits
Line
Count
Source
363
32.4M
{
364
32.4M
    BitContainerType const value = BIT_lookBits(bitD, nbBits);
365
32.4M
    BIT_skipBits(bitD, nbBits);
366
32.4M
    return value;
367
32.4M
}
Unexecuted instantiation: entropy_common.c:BIT_readBits
fse_decompress.c:BIT_readBits
Line
Count
Source
363
20.9k
{
364
20.9k
    BitContainerType const value = BIT_lookBits(bitD, nbBits);
365
20.9k
    BIT_skipBits(bitD, nbBits);
366
20.9k
    return value;
367
20.9k
}
Unexecuted instantiation: fse_compress.c:BIT_readBits
Unexecuted instantiation: huf_compress.c:BIT_readBits
Unexecuted instantiation: huf_decompress.c:BIT_readBits
Unexecuted instantiation: zstd_ddict.c:BIT_readBits
368
369
/*! BIT_readBitsFast() :
370
 *  unsafe version; only works if nbBits >= 1 */
371
MEM_STATIC BitContainerType BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
372
7.62M
{
373
7.62M
    BitContainerType const value = BIT_lookBitsFast(bitD, nbBits);
374
7.62M
    assert(nbBits >= 1);
375
7.62M
    BIT_skipBits(bitD, nbBits);
376
7.62M
    return value;
377
7.62M
}
Unexecuted instantiation: zstd_common.c:BIT_readBitsFast
Unexecuted instantiation: zstd_compress.c:BIT_readBitsFast
Unexecuted instantiation: zstd_compress_literals.c:BIT_readBitsFast
Unexecuted instantiation: zstd_compress_sequences.c:BIT_readBitsFast
Unexecuted instantiation: zstd_compress_superblock.c:BIT_readBitsFast
Unexecuted instantiation: zstd_double_fast.c:BIT_readBitsFast
Unexecuted instantiation: zstd_fast.c:BIT_readBitsFast
Unexecuted instantiation: zstd_lazy.c:BIT_readBitsFast
Unexecuted instantiation: zstd_ldm.c:BIT_readBitsFast
Unexecuted instantiation: zstd_opt.c:BIT_readBitsFast
Unexecuted instantiation: zstd_preSplit.c:BIT_readBitsFast
Unexecuted instantiation: zstd_decompress.c:BIT_readBitsFast
zstd_decompress_block.c:BIT_readBitsFast
Line
Count
Source
372
7.61M
{
373
7.61M
    BitContainerType const value = BIT_lookBitsFast(bitD, nbBits);
374
7.61M
    assert(nbBits >= 1);
375
7.61M
    BIT_skipBits(bitD, nbBits);
376
7.61M
    return value;
377
7.61M
}
Unexecuted instantiation: entropy_common.c:BIT_readBitsFast
fse_decompress.c:BIT_readBitsFast
Line
Count
Source
372
7.48k
{
373
7.48k
    BitContainerType const value = BIT_lookBitsFast(bitD, nbBits);
374
7.48k
    assert(nbBits >= 1);
375
7.48k
    BIT_skipBits(bitD, nbBits);
376
7.48k
    return value;
377
7.48k
}
Unexecuted instantiation: fse_compress.c:BIT_readBitsFast
Unexecuted instantiation: huf_compress.c:BIT_readBitsFast
Unexecuted instantiation: huf_decompress.c:BIT_readBitsFast
Unexecuted instantiation: zstd_ddict.c:BIT_readBitsFast
378
379
/*! BIT_reloadDStream_internal() :
380
 *  Simple variant of BIT_reloadDStream(), with two conditions:
381
 *  1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8
382
 *  2. look window is valid after shifted down : bitD->ptr >= bitD->start
383
 */
384
MEM_STATIC BIT_DStream_status BIT_reloadDStream_internal(BIT_DStream_t* bitD)
385
83.3k
{
386
83.3k
    assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
387
83.3k
    bitD->ptr -= bitD->bitsConsumed >> 3;
388
83.3k
    assert(bitD->ptr >= bitD->start);
389
83.3k
    bitD->bitsConsumed &= 7;
390
83.3k
    bitD->bitContainer = MEM_readLEST(bitD->ptr);
391
83.3k
    return BIT_DStream_unfinished;
392
83.3k
}
Unexecuted instantiation: zstd_common.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_compress.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_compress_literals.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_compress_sequences.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_compress_superblock.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_double_fast.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_fast.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_lazy.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_ldm.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_opt.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_preSplit.c:BIT_reloadDStream_internal
Unexecuted instantiation: zstd_decompress.c:BIT_reloadDStream_internal
zstd_decompress_block.c:BIT_reloadDStream_internal
Line
Count
Source
385
81.4k
{
386
81.4k
    assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
387
81.4k
    bitD->ptr -= bitD->bitsConsumed >> 3;
388
81.4k
    assert(bitD->ptr >= bitD->start);
389
81.4k
    bitD->bitsConsumed &= 7;
390
81.4k
    bitD->bitContainer = MEM_readLEST(bitD->ptr);
391
81.4k
    return BIT_DStream_unfinished;
392
81.4k
}
Unexecuted instantiation: entropy_common.c:BIT_reloadDStream_internal
fse_decompress.c:BIT_reloadDStream_internal
Line
Count
Source
385
1.70k
{
386
1.70k
    assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
387
1.70k
    bitD->ptr -= bitD->bitsConsumed >> 3;
388
1.70k
    assert(bitD->ptr >= bitD->start);
389
1.70k
    bitD->bitsConsumed &= 7;
390
1.70k
    bitD->bitContainer = MEM_readLEST(bitD->ptr);
391
1.70k
    return BIT_DStream_unfinished;
392
1.70k
}
Unexecuted instantiation: fse_compress.c:BIT_reloadDStream_internal
Unexecuted instantiation: huf_compress.c:BIT_reloadDStream_internal
huf_decompress.c:BIT_reloadDStream_internal
Line
Count
Source
385
149
{
386
149
    assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
387
149
    bitD->ptr -= bitD->bitsConsumed >> 3;
388
149
    assert(bitD->ptr >= bitD->start);
389
149
    bitD->bitsConsumed &= 7;
390
149
    bitD->bitContainer = MEM_readLEST(bitD->ptr);
391
149
    return BIT_DStream_unfinished;
392
149
}
Unexecuted instantiation: zstd_ddict.c:BIT_reloadDStream_internal
393
394
/*! BIT_reloadDStreamFast() :
395
 *  Similar to BIT_reloadDStream(), but with two differences:
396
 *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
397
 *  2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
398
 *     point you must use BIT_reloadDStream() to reload.
399
 */
400
MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
401
0
{
402
0
    if (UNLIKELY(bitD->ptr < bitD->limitPtr))
403
0
        return BIT_DStream_overflow;
404
0
    return BIT_reloadDStream_internal(bitD);
405
0
}
Unexecuted instantiation: zstd_common.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_compress.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_compress_literals.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_compress_sequences.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_compress_superblock.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_double_fast.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_fast.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_lazy.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_ldm.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_opt.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_preSplit.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_decompress.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_decompress_block.c:BIT_reloadDStreamFast
Unexecuted instantiation: entropy_common.c:BIT_reloadDStreamFast
Unexecuted instantiation: fse_decompress.c:BIT_reloadDStreamFast
Unexecuted instantiation: fse_compress.c:BIT_reloadDStreamFast
Unexecuted instantiation: huf_compress.c:BIT_reloadDStreamFast
Unexecuted instantiation: huf_decompress.c:BIT_reloadDStreamFast
Unexecuted instantiation: zstd_ddict.c:BIT_reloadDStreamFast
406
407
/*! BIT_reloadDStream() :
408
 *  Refill `bitD` from buffer previously set in BIT_initDStream() .
409
 *  This function is safe, it guarantees it will not never beyond src buffer.
410
 * @return : status of `BIT_DStream_t` internal register.
411
 *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
412
FORCE_INLINE_TEMPLATE BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
413
10.8M
{
414
    /* note : once in overflow mode, a bitstream remains in this mode until it's reset */
415
10.8M
    if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {
416
10.7M
        static const BitContainerType zeroFilled = 0;
417
10.7M
        bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */
418
        /* overflow detected, erroneous scenario or end of stream: no update */
419
10.7M
        return BIT_DStream_overflow;
420
10.7M
    }
421
422
141k
    assert(bitD->ptr >= bitD->start);
423
424
141k
    if (bitD->ptr >= bitD->limitPtr) {
425
83.3k
        return BIT_reloadDStream_internal(bitD);
426
83.3k
    }
427
58.4k
    if (bitD->ptr == bitD->start) {
428
        /* reached end of bitStream => no update */
429
35.7k
        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
430
748
        return BIT_DStream_completed;
431
35.7k
    }
432
    /* start < ptr < limitPtr => cautious update */
433
22.6k
    {   U32 nbBytes = bitD->bitsConsumed >> 3;
434
22.6k
        BIT_DStream_status result = BIT_DStream_unfinished;
435
22.6k
        if (bitD->ptr - nbBytes < bitD->start) {
436
2.13k
            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
437
2.13k
            result = BIT_DStream_endOfBuffer;
438
2.13k
        }
439
22.6k
        bitD->ptr -= nbBytes;
440
22.6k
        bitD->bitsConsumed -= nbBytes*8;
441
22.6k
        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
442
22.6k
        return result;
443
58.4k
    }
444
58.4k
}
Unexecuted instantiation: zstd_common.c:BIT_reloadDStream
Unexecuted instantiation: zstd_compress.c:BIT_reloadDStream
Unexecuted instantiation: zstd_compress_literals.c:BIT_reloadDStream
Unexecuted instantiation: zstd_compress_sequences.c:BIT_reloadDStream
Unexecuted instantiation: zstd_compress_superblock.c:BIT_reloadDStream
Unexecuted instantiation: zstd_double_fast.c:BIT_reloadDStream
Unexecuted instantiation: zstd_fast.c:BIT_reloadDStream
Unexecuted instantiation: zstd_lazy.c:BIT_reloadDStream
Unexecuted instantiation: zstd_ldm.c:BIT_reloadDStream
Unexecuted instantiation: zstd_opt.c:BIT_reloadDStream
Unexecuted instantiation: zstd_preSplit.c:BIT_reloadDStream
Unexecuted instantiation: zstd_decompress.c:BIT_reloadDStream
zstd_decompress_block.c:BIT_reloadDStream
Line
Count
Source
413
10.8M
{
414
    /* note : once in overflow mode, a bitstream remains in this mode until it's reset */
415
10.8M
    if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {
416
10.7M
        static const BitContainerType zeroFilled = 0;
417
10.7M
        bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */
418
        /* overflow detected, erroneous scenario or end of stream: no update */
419
10.7M
        return BIT_DStream_overflow;
420
10.7M
    }
421
422
123k
    assert(bitD->ptr >= bitD->start);
423
424
123k
    if (bitD->ptr >= bitD->limitPtr) {
425
81.4k
        return BIT_reloadDStream_internal(bitD);
426
81.4k
    }
427
42.0k
    if (bitD->ptr == bitD->start) {
428
        /* reached end of bitStream => no update */
429
22.1k
        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
430
486
        return BIT_DStream_completed;
431
22.1k
    }
432
    /* start < ptr < limitPtr => cautious update */
433
19.8k
    {   U32 nbBytes = bitD->bitsConsumed >> 3;
434
19.8k
        BIT_DStream_status result = BIT_DStream_unfinished;
435
19.8k
        if (bitD->ptr - nbBytes < bitD->start) {
436
2.06k
            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
437
2.06k
            result = BIT_DStream_endOfBuffer;
438
2.06k
        }
439
19.8k
        bitD->ptr -= nbBytes;
440
19.8k
        bitD->bitsConsumed -= nbBytes*8;
441
19.8k
        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
442
19.8k
        return result;
443
42.0k
    }
444
42.0k
}
Unexecuted instantiation: entropy_common.c:BIT_reloadDStream
fse_decompress.c:BIT_reloadDStream
Line
Count
Source
413
18.2k
{
414
    /* note : once in overflow mode, a bitstream remains in this mode until it's reset */
415
18.2k
    if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {
416
406
        static const BitContainerType zeroFilled = 0;
417
406
        bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */
418
        /* overflow detected, erroneous scenario or end of stream: no update */
419
406
        return BIT_DStream_overflow;
420
406
    }
421
422
17.8k
    assert(bitD->ptr >= bitD->start);
423
424
17.8k
    if (bitD->ptr >= bitD->limitPtr) {
425
1.70k
        return BIT_reloadDStream_internal(bitD);
426
1.70k
    }
427
16.1k
    if (bitD->ptr == bitD->start) {
428
        /* reached end of bitStream => no update */
429
13.5k
        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
430
262
        return BIT_DStream_completed;
431
13.5k
    }
432
    /* start < ptr < limitPtr => cautious update */
433
2.64k
    {   U32 nbBytes = bitD->bitsConsumed >> 3;
434
2.64k
        BIT_DStream_status result = BIT_DStream_unfinished;
435
2.64k
        if (bitD->ptr - nbBytes < bitD->start) {
436
57
            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
437
57
            result = BIT_DStream_endOfBuffer;
438
57
        }
439
2.64k
        bitD->ptr -= nbBytes;
440
2.64k
        bitD->bitsConsumed -= nbBytes*8;
441
2.64k
        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
442
2.64k
        return result;
443
16.1k
    }
444
16.1k
}
Unexecuted instantiation: fse_compress.c:BIT_reloadDStream
Unexecuted instantiation: huf_compress.c:BIT_reloadDStream
huf_decompress.c:BIT_reloadDStream
Line
Count
Source
413
376
{
414
    /* note : once in overflow mode, a bitstream remains in this mode until it's reset */
415
376
    if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {
416
0
        static const BitContainerType zeroFilled = 0;
417
0
        bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */
418
        /* overflow detected, erroneous scenario or end of stream: no update */
419
0
        return BIT_DStream_overflow;
420
0
    }
421
422
376
    assert(bitD->ptr >= bitD->start);
423
424
376
    if (bitD->ptr >= bitD->limitPtr) {
425
149
        return BIT_reloadDStream_internal(bitD);
426
149
    }
427
227
    if (bitD->ptr == bitD->start) {
428
        /* reached end of bitStream => no update */
429
45
        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
430
0
        return BIT_DStream_completed;
431
45
    }
432
    /* start < ptr < limitPtr => cautious update */
433
182
    {   U32 nbBytes = bitD->bitsConsumed >> 3;
434
182
        BIT_DStream_status result = BIT_DStream_unfinished;
435
182
        if (bitD->ptr - nbBytes < bitD->start) {
436
14
            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
437
14
            result = BIT_DStream_endOfBuffer;
438
14
        }
439
182
        bitD->ptr -= nbBytes;
440
182
        bitD->bitsConsumed -= nbBytes*8;
441
182
        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
442
182
        return result;
443
227
    }
444
227
}
Unexecuted instantiation: zstd_ddict.c:BIT_reloadDStream
445
446
/*! BIT_endOfDStream() :
447
 * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
448
 */
449
MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
450
322
{
451
322
    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
452
322
}
Unexecuted instantiation: zstd_common.c:BIT_endOfDStream
Unexecuted instantiation: zstd_compress.c:BIT_endOfDStream
Unexecuted instantiation: zstd_compress_literals.c:BIT_endOfDStream
Unexecuted instantiation: zstd_compress_sequences.c:BIT_endOfDStream
Unexecuted instantiation: zstd_compress_superblock.c:BIT_endOfDStream
Unexecuted instantiation: zstd_double_fast.c:BIT_endOfDStream
Unexecuted instantiation: zstd_fast.c:BIT_endOfDStream
Unexecuted instantiation: zstd_lazy.c:BIT_endOfDStream
Unexecuted instantiation: zstd_ldm.c:BIT_endOfDStream
Unexecuted instantiation: zstd_opt.c:BIT_endOfDStream
Unexecuted instantiation: zstd_preSplit.c:BIT_endOfDStream
Unexecuted instantiation: zstd_decompress.c:BIT_endOfDStream
zstd_decompress_block.c:BIT_endOfDStream
Line
Count
Source
450
258
{
451
258
    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
452
258
}
Unexecuted instantiation: entropy_common.c:BIT_endOfDStream
Unexecuted instantiation: fse_decompress.c:BIT_endOfDStream
Unexecuted instantiation: fse_compress.c:BIT_endOfDStream
Unexecuted instantiation: huf_compress.c:BIT_endOfDStream
huf_decompress.c:BIT_endOfDStream
Line
Count
Source
450
64
{
451
64
    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
452
64
}
Unexecuted instantiation: zstd_ddict.c:BIT_endOfDStream
453
454
#endif /* BITSTREAM_H_MODULE */