zstd_internal.h File Reference

#include "compiler.h"
#include "mem.h"
#include "debug.h"
#include "error_private.h"
#include "zstd.h"
#include "fse.h"
#include "huf.h"
#include "../xxhash.h"

Include dependency graph for zstd_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	seqDef_s
struct	seqStore_t
struct	ZSTD_sequenceLength
struct	ZSTD_frameSizeInfo
struct	blockProperties_t

Macros
#define	ZSTD_STATIC_LINKING_ONLY
#define	FSE_STATIC_LINKING_ONLY
#define	HUF_STATIC_LINKING_ONLY
#define	XXH_STATIC_LINKING_ONLY   /* XXH64_state_t */
#define	ZSTD_STATIC_ASSERT(c)   DEBUG_STATIC_ASSERT(c)
#define	ZSTD_isError   ERR_isError /* for inlining */
#define	FSE_isError   ERR_isError
#define	HUF_isError   ERR_isError
#define	MIN(a, b)   ((a)<(b) ? (a) : (b))
#define	MAX(a, b)   ((a)>(b) ? (a) : (b))
#define	_FORCE_HAS_FORMAT_STRING(...)
#define	RETURN_ERROR_IF(cond, err, ...)
#define	RETURN_ERROR(err, ...)
#define	FORWARD_IF_ERROR(err, ...)
#define	ZSTD_OPT_NUM   (1<<12)
#define	ZSTD_REP_NUM   3 /* number of repcodes */
#define	ZSTD_REP_MOVE   (ZSTD_REP_NUM-1)
#define	KB   *(1 <<10)
#define	MB   *(1 <<20)
#define	GB   *(1U<<30)
#define	BIT7   128
#define	BIT6   64
#define	BIT5   32
#define	BIT4   16
#define	BIT1   2
#define	BIT0   1
#define	ZSTD_WINDOWLOG_ABSOLUTEMIN   10
#define	ZSTD_FRAMEIDSIZE   4 /* magic number size */
#define	ZSTD_BLOCKHEADERSIZE   3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
#define	ZSTD_FRAMECHECKSUMSIZE   4
#define	MIN_SEQUENCES_SIZE   1 /* nbSeq==0 */
#define	MIN_CBLOCK_SIZE   (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */
#define	HufLog   12
#define	LONGNBSEQ   0x7F00
#define	MINMATCH   3
#define	Litbits   8
#define	MaxLit   ((1<<Litbits) - 1)
#define	MaxML   52
#define	MaxLL   35
#define	DefaultMaxOff   28
#define	MaxOff   31
#define	MaxSeq   MAX(MaxLL, MaxML) /* Assumption : MaxOff < MaxLL,MaxML */
#define	MLFSELog   9
#define	LLFSELog   9
#define	OffFSELog   8
#define	MaxFSELog   MAX(MAX(MLFSELog, LLFSELog), OffFSELog)
#define	LL_DEFAULTNORMLOG   6 /* for static allocation */
#define	ML_DEFAULTNORMLOG   6 /* for static allocation */
#define	OF_DEFAULTNORMLOG   5 /* for static allocation */
#define	COPY8(d, s)   { ZSTD_copy8(d,s); d+=8; s+=8; }
#define	COPY16(d, s)   { ZSTD_copy16(d,s); d+=16; s+=16; }
#define	WILDCOPY_OVERLENGTH   32
#define	WILDCOPY_VECLEN   16
#define	ZSTD_WORKSPACETOOLARGE_FACTOR   3
#define	ZSTD_WORKSPACETOOLARGE_MAXDURATION   128

Typedefs
typedef struct seqDef_s	seqDef

Enumerations
enum	blockType_e { bt_raw , bt_rle , bt_compressed , bt_reserved }
enum	symbolEncodingType_e { set_basic , set_rle , set_compressed , set_repeat }
enum	ZSTD_overlap_e { ZSTD_no_overlap , ZSTD_overlap_src_before_dst }

Functions
static INLINE_KEYWORD UNUSED_ATTR void	_force_has_format_string (const char *format,...)
static void	ZSTD_copy8 (void *dst, const void *src)
static void	ZSTD_copy16 (void *dst, const void *src)
MEM_STATIC FORCE_INLINE_ATTR void	ZSTD_wildcopy (void *dst, const void *src, ptrdiff_t length, ZSTD_overlap_e const ovtype)
MEM_STATIC size_t	ZSTD_limitCopy (void *dst, size_t dstCapacity, const void *src, size_t srcSize)
MEM_STATIC ZSTD_sequenceLength	ZSTD_getSequenceLength (seqStore_t const *seqStore, seqDef const *seq)
const seqStore_t *	ZSTD_getSeqStore (const ZSTD_CCtx *ctx)
void	ZSTD_seqToCodes (const seqStore_t *seqStorePtr)
void *	ZSTD_malloc (size_t size, ZSTD_customMem customMem)
void *	ZSTD_calloc (size_t size, ZSTD_customMem customMem)
void	ZSTD_free (void *ptr, ZSTD_customMem customMem)
MEM_STATIC U32	ZSTD_highbit32 (U32 val)
void	ZSTD_invalidateRepCodes (ZSTD_CCtx *cctx)
size_t	ZSTD_getcBlockSize (const void *src, size_t srcSize, blockProperties_t *bpPtr)
size_t	ZSTD_decodeSeqHeaders (ZSTD_DCtx *dctx, int *nbSeqPtr, const void *src, size_t srcSize)

Variables
static const U32	repStartValue [ZSTD_REP_NUM] = { 1, 4, 8 }
static const size_t	ZSTD_fcs_fieldSize [4] = { 0, 2, 4, 8 }
static const size_t	ZSTD_did_fieldSize [4] = { 0, 1, 2, 4 }
static const size_t	ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE
static const U32	LL_bits [MaxLL+1]
static const S16	LL_defaultNorm [MaxLL+1]
static const U32	LL_defaultNormLog = LL_DEFAULTNORMLOG
static const U32	ML_bits [MaxML+1]
static const S16	ML_defaultNorm [MaxML+1]
static const U32	ML_defaultNormLog = ML_DEFAULTNORMLOG
static const S16	OF_defaultNorm [DefaultMaxOff+1]
static const U32	OF_defaultNormLog = OF_DEFAULTNORMLOG

Macro Definition Documentation

_FORCE_HAS_FORMAT_STRING

#define _FORCE_HAS_FORMAT_STRING

(

...

)

Value:

  if (0) { \
    _force_has_format_string(__VA_ARGS__); \
  }

Ignore: this is an internal helper.

We want to force this function invocation to be syntactically correct, but we don't want to force runtime evaluation of its arguments.

Definition at line 79 of file zstd_internal.h.

BIT0

#define BIT0   1

Definition at line 153 of file zstd_internal.h.

BIT1

#define BIT1   2

Definition at line 152 of file zstd_internal.h.

BIT4

#define BIT4   16

Definition at line 151 of file zstd_internal.h.

BIT5

#define BIT5   32

Definition at line 150 of file zstd_internal.h.

BIT6

#define BIT6   64

Definition at line 149 of file zstd_internal.h.

BIT7

#define BIT7   128

Definition at line 148 of file zstd_internal.h.

COPY16

#define COPY16	(		d,
			s
	)		{ ZSTD_copy16(d,s); d+=16; s+=16; }

Definition at line 246 of file zstd_internal.h.

COPY8

#define COPY8	(		d,
			s
	)		{ ZSTD_copy8(d,s); d+=8; s+=8; }

Definition at line 238 of file zstd_internal.h.

DefaultMaxOff

#define DefaultMaxOff   28

Definition at line 181 of file zstd_internal.h.

FORWARD_IF_ERROR

#define FORWARD_IF_ERROR	(		err,
			...
	)

Value:

  do { \
    size_t const err_code = (err); \
    if (ERR_isError(err_code)) { \
      RAWLOG(3, "%s:%d: ERROR!: forwarding error in %s: %s", \
             __FILE__, __LINE__, ZSTD_QUOTE(err), ERR_getErrorName(err_code)); \
      _FORCE_HAS_FORMAT_STRING(__VA_ARGS__); \
      RAWLOG(3, ": " __VA_ARGS__); \
      RAWLOG(3, "\n"); \
      return err_code; \
    } \
  } while(0);

If the provided expression evaluates to an error code, returns that error code.

In debug modes, prints additional information.

Definition at line 121 of file zstd_internal.h.

FSE_isError

#define FSE_isError   ERR_isError

Definition at line 47 of file zstd_internal.h.

FSE_STATIC_LINKING_ONLY

#define FSE_STATIC_LINKING_ONLY

Definition at line 31 of file zstd_internal.h.

GB

#define GB   *(1U<<30)

Definition at line 146 of file zstd_internal.h.

HUF_isError

#define HUF_isError   ERR_isError

Definition at line 48 of file zstd_internal.h.

HUF_STATIC_LINKING_ONLY

#define HUF_STATIC_LINKING_ONLY

Definition at line 33 of file zstd_internal.h.

HufLog

#define HufLog   12

Definition at line 170 of file zstd_internal.h.

KB

#define KB   *(1 <<10)

Definition at line 144 of file zstd_internal.h.

Litbits

#define Litbits   8

Definition at line 177 of file zstd_internal.h.

LL_DEFAULTNORMLOG

#define LL_DEFAULTNORMLOG   6 /* for static allocation */

Definition at line 199 of file zstd_internal.h.

LLFSELog

#define LLFSELog   9

Definition at line 185 of file zstd_internal.h.

LONGNBSEQ

#define LONGNBSEQ   0x7F00

Definition at line 173 of file zstd_internal.h.

MAX

#define MAX	(		a,
			b
	)		((a)>(b) ? (a) : (b))

Definition at line 57 of file zstd_internal.h.

MaxFSELog

#define MaxFSELog   MAX(MAX(MLFSELog, LLFSELog), OffFSELog)

Definition at line 187 of file zstd_internal.h.

MaxLit

#define MaxLit   ((1<<Litbits) - 1)

Definition at line 178 of file zstd_internal.h.

MaxLL

#define MaxLL   35

Definition at line 180 of file zstd_internal.h.

MaxML

#define MaxML   52

Definition at line 179 of file zstd_internal.h.

MaxOff

#define MaxOff   31

Definition at line 182 of file zstd_internal.h.

MaxSeq

#define MaxSeq   MAX(MaxLL, MaxML) /* Assumption : MaxOff < MaxLL,MaxML */

Definition at line 183 of file zstd_internal.h.

MB

#define MB   *(1 <<20)

Definition at line 145 of file zstd_internal.h.

MIN

#define MIN	(		a,
			b
	)		((a)<(b) ? (a) : (b))

Definition at line 56 of file zstd_internal.h.

MIN_CBLOCK_SIZE

#define MIN_CBLOCK_SIZE   (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */

Definition at line 168 of file zstd_internal.h.

MIN_SEQUENCES_SIZE

#define MIN_SEQUENCES_SIZE   1 /* nbSeq==0 */

Definition at line 167 of file zstd_internal.h.

MINMATCH

#define MINMATCH   3

Definition at line 175 of file zstd_internal.h.

ML_DEFAULTNORMLOG

#define ML_DEFAULTNORMLOG   6 /* for static allocation */

Definition at line 216 of file zstd_internal.h.

MLFSELog

#define MLFSELog   9

Definition at line 184 of file zstd_internal.h.

OF_DEFAULTNORMLOG

#define OF_DEFAULTNORMLOG   5 /* for static allocation */

Definition at line 223 of file zstd_internal.h.

OffFSELog

#define OffFSELog   8

Definition at line 186 of file zstd_internal.h.

RETURN_ERROR

#define RETURN_ERROR	(		err,
			...
	)

Value:

  do { \
    RAWLOG(3, "%s:%d: ERROR!: unconditional check failed, returning %s", \
           __FILE__, __LINE__, ZSTD_QUOTE(ERROR(err))); \
    _FORCE_HAS_FORMAT_STRING(__VA_ARGS__); \
    RAWLOG(3, ": " __VA_ARGS__); \
    RAWLOG(3, "\n"); \
    return ERROR(err); \
  } while(0);

Unconditionally return the specified error.

In debug modes, prints additional information.

Definition at line 106 of file zstd_internal.h.

RETURN_ERROR_IF

#define RETURN_ERROR_IF	(		cond,
			err,
			...
	)

Value:

  if (cond) { \
    RAWLOG(3, "%s:%d: ERROR!: check %s failed, returning %s", \
           __FILE__, __LINE__, ZSTD_QUOTE(cond), ZSTD_QUOTE(ERROR(err))); \
    _FORCE_HAS_FORMAT_STRING(__VA_ARGS__); \
    RAWLOG(3, ": " __VA_ARGS__); \
    RAWLOG(3, "\n"); \
    return ERROR(err); \
  }

Return the specified error if the condition evaluates to true.

In debug modes, prints additional information. In order to do that (particularly, printing the conditional that failed), this can't just wrap RETURN_ERROR().

Definition at line 91 of file zstd_internal.h.

WILDCOPY_OVERLENGTH

#define WILDCOPY_OVERLENGTH   32

Definition at line 248 of file zstd_internal.h.

WILDCOPY_VECLEN

#define WILDCOPY_VECLEN   16

Definition at line 249 of file zstd_internal.h.

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY   /* XXH64_state_t */

Definition at line 36 of file zstd_internal.h.

ZSTD_BLOCKHEADERSIZE

#define ZSTD_BLOCKHEADERSIZE   3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */

Definition at line 161 of file zstd_internal.h.

ZSTD_FRAMECHECKSUMSIZE

#define ZSTD_FRAMECHECKSUMSIZE   4

Definition at line 165 of file zstd_internal.h.

ZSTD_FRAMEIDSIZE

#define ZSTD_FRAMEIDSIZE   4 /* magic number size */

Definition at line 159 of file zstd_internal.h.

ZSTD_isError

#define ZSTD_isError   ERR_isError /* for inlining */

Definition at line 46 of file zstd_internal.h.

ZSTD_OPT_NUM

#define ZSTD_OPT_NUM   (1<<12)

Definition at line 138 of file zstd_internal.h.

ZSTD_REP_MOVE

#define ZSTD_REP_MOVE   (ZSTD_REP_NUM-1)

Definition at line 141 of file zstd_internal.h.

ZSTD_REP_NUM

#define ZSTD_REP_NUM   3 /* number of repcodes */

Definition at line 140 of file zstd_internal.h.

ZSTD_STATIC_ASSERT

#define ZSTD_STATIC_ASSERT

(

c

)

DEBUG_STATIC_ASSERT(c)

Definition at line 45 of file zstd_internal.h.

ZSTD_STATIC_LINKING_ONLY

#define ZSTD_STATIC_LINKING_ONLY

Definition at line 29 of file zstd_internal.h.

ZSTD_WINDOWLOG_ABSOLUTEMIN

#define ZSTD_WINDOWLOG_ABSOLUTEMIN   10

Definition at line 155 of file zstd_internal.h.

ZSTD_WORKSPACETOOLARGE_FACTOR

#define ZSTD_WORKSPACETOOLARGE_FACTOR   3

Definition at line 314 of file zstd_internal.h.

ZSTD_WORKSPACETOOLARGE_MAXDURATION

#define ZSTD_WORKSPACETOOLARGE_MAXDURATION   128

Definition at line 321 of file zstd_internal.h.

Typedef Documentation

seqDef

typedef struct seqDef_s seqDef

Enumeration Type Documentation

blockType_e

enum blockType_e

Enumerator
bt_raw
bt_rle
bt_compressed
bt_reserved

Definition at line 163 of file zstd_internal.h.

{ bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;

symbolEncodingType_e

enum symbolEncodingType_e

Enumerator
set_basic
set_rle
set_compressed
set_repeat

Definition at line 171 of file zstd_internal.h.

{ set_basic, set_rle, set_compressed, set_repeat } symbolEncodingType_e;

ZSTD_overlap_e

enum ZSTD_overlap_e

Enumerator
ZSTD_no_overlap
ZSTD_overlap_src_before_dst

Definition at line 251 of file zstd_internal.h.

             {
    ZSTD_no_overlap,
    ZSTD_overlap_src_before_dst
    /*  ZSTD_overlap_dst_before_src, */
} ZSTD_overlap_e;

Function Documentation

_force_has_format_string()

static INLINE_KEYWORD UNUSED_ATTR void _force_has_format_string ( const char *  format,   ...  )

static

Ignore: this is an internal helper.

This is a helper function to help force C99-correctness during compilation. Under strict compilation modes, variadic macro arguments can't be empty. However, variadic function arguments can be. Using a function therefore lets us statically check that at least one (string) argument was passed, independent of the compilation flags.

Definition at line 69 of file zstd_internal.h.

                                                       {
  (void)format;
}

ZSTD_calloc()

void * ZSTD_calloc	(	size_t	size,
		ZSTD_customMem	customMem
	)

Definition at line 61 of file zstd_common.c.

{
    /* calloc implemented as malloc+memset;
        * not as efficient as calloc, but next best guess for custom malloc */
    void* const ptr = customMem.customAlloc(customMem.opaque, size);
    memset(ptr, 0, size);
    return ptr;
}

Referenced by ZSTD_createCCtxParams_advanced().

ZSTD_copy16()

static void ZSTD_copy16 ( void *  dst, const void *  src  )

static

Definition at line 239 of file zstd_internal.h.

                                                    {
#ifdef __aarch64__
    vst1q_u8((uint8_t*)dst, vld1q_u8((const uint8_t*)src));
#else
    memcpy(dst, src, 16);
#endif
}

ZSTD_copy8()

static void ZSTD_copy8 ( void *  dst, const void *  src  )

static

Definition at line 230 of file zstd_internal.h.

                                                   {
#ifdef __aarch64__
    vst1_u8((uint8_t*)dst, vld1_u8((const uint8_t*)src));
#else
    memcpy(dst, src, 8);
#endif
}

ZSTD_decodeSeqHeaders()

size_t ZSTD_decodeSeqHeaders	(	ZSTD_DCtx *	dctx,
		int *	nbSeqPtr,
		const void *	src,
		size_t	srcSize
	)

ZSTD_decodeSeqHeaders() : decode sequence header from src

Definition at line 480 of file zstd_decompress_block.c.

{
    const BYTE* const istart = (const BYTE* const)src;
    const BYTE* const iend = istart + srcSize;
    const BYTE* ip = istart;
    int nbSeq;
    DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
 
    /* check */
    RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, "");
 
    /* SeqHead */
    nbSeq = *ip++;
    if (!nbSeq) {
        *nbSeqPtr=0;
        RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, "");
        return 1;
    }
    if (nbSeq > 0x7F) {
        if (nbSeq == 0xFF) {
            RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, "");
            nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
        } else {
            RETURN_ERROR_IF(ip >= iend, srcSize_wrong, "");
            nbSeq = ((nbSeq-0x80)<<8) + *ip++;
        }
    }
    *nbSeqPtr = nbSeq;
 
    /* FSE table descriptors */
    RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */
    {   symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
        symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
        symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
        ip++;
 
        /* Build DTables */
        {   size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
                                                      LLtype, MaxLL, LLFSELog,
                                                      ip, iend-ip,
                                                      LL_base, LL_bits,
                                                      LL_defaultDTable, dctx->fseEntropy,
                                                      dctx->ddictIsCold, nbSeq);
            RETURN_ERROR_IF(ZSTD_isError(llhSize), corruption_detected, "ZSTD_buildSeqTable failed");
            ip += llhSize;
        }
 
        {   size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
                                                      OFtype, MaxOff, OffFSELog,
                                                      ip, iend-ip,
                                                      OF_base, OF_bits,
                                                      OF_defaultDTable, dctx->fseEntropy,
                                                      dctx->ddictIsCold, nbSeq);
            RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed");
            ip += ofhSize;
        }
 
        {   size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
                                                      MLtype, MaxML, MLFSELog,
                                                      ip, iend-ip,
                                                      ML_base, ML_bits,
                                                      ML_defaultDTable, dctx->fseEntropy,
                                                      dctx->ddictIsCold, nbSeq);
            RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, "ZSTD_buildSeqTable failed");
            ip += mlhSize;
        }
    }
 
    return ip-istart;
}

ZSTD_free()

void ZSTD_free	(	void *	ptr,
		ZSTD_customMem	customMem
	)

Definition at line 70 of file zstd_common.c.

{
    if (ptr!=NULL)
        customMem.customFree(customMem.opaque, ptr);
}

Referenced by ZSTD_clearAllDicts(), ZSTD_createCDict_advanced(), ZSTD_cwksp_free(), ZSTD_decompressStream(), ZSTD_freeCCtx(), ZSTD_freeCCtxParams(), ZSTD_freeCDict(), ZSTD_freeDCtx(), ZSTD_freeDDict(), and ZSTD_getSequences().

ZSTD_getcBlockSize()

size_t ZSTD_getcBlockSize	(	const void *	src,
		size_t	srcSize,
		blockProperties_t *	bpPtr
	)

ZSTD_getcBlockSize() : Provides the size of compressed block from block header src

Definition at line 56 of file zstd_decompress_block.c.

{
    RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong, "");
 
    {   U32 const cBlockHeader = MEM_readLE24(src);
        U32 const cSize = cBlockHeader >> 3;
        bpPtr->lastBlock = cBlockHeader & 1;
        bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
        bpPtr->origSize = cSize;   /* only useful for RLE */
        if (bpPtr->blockType == bt_rle) return 1;
        RETURN_ERROR_IF(bpPtr->blockType == bt_reserved, corruption_detected, "");
        return cSize;
    }
}

Referenced by ZSTD_decompressContinue(), ZSTD_decompressFrame(), and ZSTD_findFrameSizeInfo().

ZSTD_getSeqStore()

const seqStore_t * ZSTD_getSeqStore

(

const ZSTD_CCtx *

ctx

)

Definition at line 190 of file zstd_compress.c.

{ return &(ctx->seqStore); }

Referenced by ZSTD_copyBlockSequences().

ZSTD_getSequenceLength()

MEM_STATIC ZSTD_sequenceLength ZSTD_getSequenceLength	(	seqStore_t const *	seqStore,
		seqDef const *	seq
	)

Returns the ZSTD_sequenceLength for the given sequences. It handles the decoding of long sequences indicated by longLengthPos and longLengthID, and adds MINMATCH back to matchLength.

Definition at line 356 of file zstd_internal.h.

{
    ZSTD_sequenceLength seqLen;
    seqLen.litLength = seq->litLength;
    seqLen.matchLength = seq->matchLength + MINMATCH;
    if (seqStore->longLengthPos == (U32)(seq - seqStore->sequencesStart)) {
        if (seqStore->longLengthID == 1) {
            seqLen.litLength += 0xFFFF;
        }
        if (seqStore->longLengthID == 2) {
            seqLen.matchLength += 0xFFFF;
        }
    }
    return seqLen;
}

Referenced by ZSTD_compressSubBlock_multi(), and ZSTD_seqDecompressedSize().

ZSTD_highbit32()

MEM_STATIC U32 ZSTD_highbit32

(

U32

val

)

Definition at line 392 of file zstd_internal.h.

{
    assert(val != 0);
    {
#   if defined(_MSC_VER)   /* Visual */
        unsigned long r=0;
        return _BitScanReverse(&r, val) ? (unsigned)r : 0;
#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */
        return __builtin_clz (val) ^ 31;
#   elif defined(__ICCARM__)    /* IAR Intrinsic */
        return 31 - __CLZ(val);
#   else   /* Software version */
        static const U32 DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
        U32 v = val;
        v |= v >> 1;
        v |= v >> 2;
        v |= v >> 4;
        v |= v >> 8;
        v |= v >> 16;
        return DeBruijnClz[(v * 0x07C4ACDDU) >> 27];
#   endif
    }
}

Referenced by ZSTD_adjustCParams_internal(), ZSTD_bitWeight(), ZSTD_compressBegin_usingCDict_advanced(), ZSTD_compressBlock_lazy_extDict_generic(), ZSTD_compressBlock_lazy_generic(), ZSTD_DUBT_findBestMatch(), ZSTD_DUBT_findBetterDictMatch(), ZSTD_fracWeight(), ZSTD_getMatchPrice(), ZSTD_loadZstdDictionary(), ZSTD_seqToCodes(), and ZSTD_updateStats().

ZSTD_invalidateRepCodes()

void ZSTD_invalidateRepCodes

(

ZSTD_CCtx *

cctx

)

Definition at line 1593 of file zstd_compress.c.

                                              {
    int i;
    for (i=0; i<ZSTD_REP_NUM; i++) cctx->blockState.prevCBlock->rep[i] = 0;
    assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
}

ZSTD_limitCopy()

MEM_STATIC size_t ZSTD_limitCopy	(	void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize
	)

Definition at line 304 of file zstd_internal.h.

{
    size_t const length = MIN(dstCapacity, srcSize);
    if (length > 0) {
        memcpy(dst, src, length);
    }
    return length;
}

Referenced by ZSTD_compressStream_generic(), and ZSTD_decompressStream().

ZSTD_malloc()

void * ZSTD_malloc	(	size_t	size,
		ZSTD_customMem	customMem
	)

Definition at line 56 of file zstd_common.c.

{
    return customMem.customAlloc(customMem.opaque, size);
}

Referenced by ZSTD_CCtx_loadDictionary_advanced(), ZSTD_createCCtx_advanced(), ZSTD_createCDict_advanced(), ZSTD_createDCtx_advanced(), ZSTD_createDDict_advanced(), ZSTD_cwksp_create(), ZSTD_decompressStream(), ZSTD_getSequences(), and ZSTD_initDDict_internal().

ZSTD_seqToCodes()

void ZSTD_seqToCodes

(

const seqStore_t *

seqStorePtr

)

Definition at line 1929 of file zstd_compress.c.

{
    const seqDef* const sequences = seqStorePtr->sequencesStart;
    BYTE* const llCodeTable = seqStorePtr->llCode;
    BYTE* const ofCodeTable = seqStorePtr->ofCode;
    BYTE* const mlCodeTable = seqStorePtr->mlCode;
    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
    U32 u;
    assert(nbSeq <= seqStorePtr->maxNbSeq);
    for (u=0; u<nbSeq; u++) {
        U32 const llv = sequences[u].litLength;
        U32 const mlv = sequences[u].matchLength;
        llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
        ofCodeTable[u] = (BYTE)ZSTD_highbit32(sequences[u].offset);
        mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
    }
    if (seqStorePtr->longLengthID==1)
        llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
    if (seqStorePtr->longLengthID==2)
        mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
}

Referenced by ZSTD_buildSuperBlockEntropy_sequences(), and ZSTD_compressSequences_internal().

ZSTD_wildcopy()

MEM_STATIC FORCE_INLINE_ATTR void ZSTD_wildcopy	(	void *	dst,
		const void *	src,
		ptrdiff_t	length,
		ZSTD_overlap_e const	ovtype
	)

ZSTD_wildcopy() : Custom version of memcpy(), can over read/write up to WILDCOPY_OVERLENGTH bytes (if length==0)

Parameters

ovtype

controls the overlap detection ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart. ZSTD_overlap_src_before_dst: The src and dst may overlap, but they MUST be at least 8 bytes apart. The src buffer must be before the dst buffer.

Definition at line 265 of file zstd_internal.h.

{
    ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
    const BYTE* ip = (const BYTE*)src;
    BYTE* op = (BYTE*)dst;
    BYTE* const oend = op + length;
 
    assert(diff >= 8 || (ovtype == ZSTD_no_overlap && diff <= -WILDCOPY_VECLEN));
 
    if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
        /* Handle short offset copies. */
        do {
            COPY8(op, ip)
        } while (op < oend);
    } else {
        assert(diff >= WILDCOPY_VECLEN || diff <= -WILDCOPY_VECLEN);
        /* Separate out the first COPY16() call because the copy length is
         * almost certain to be short, so the branches have different
         * probabilities. Since it is almost certain to be short, only do
         * one COPY16() in the first call. Then, do two calls per loop since
         * at that point it is more likely to have a high trip count.
         */
#ifndef __aarch64__
        do {
            COPY16(op, ip);
        }
        while (op < oend);
#else
        COPY16(op, ip);
        if (op >= oend) return;
        do {
            COPY16(op, ip);
            COPY16(op, ip);
        }
        while (op < oend);
#endif
    }
}

Referenced by ZSTD_safecopyLiterals().

Variable Documentation

LL_bits

const U32 LL_bits[MaxLL+1]

static

Initial value:

= { 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0,
                                      1, 1, 1, 1, 2, 2, 3, 3,
                                      4, 6, 7, 8, 9,10,11,12,
                                     13,14,15,16 }

Definition at line 189 of file zstd_internal.h.

Referenced by ZSTD_encodeSequences_body(), ZSTD_estimateSubBlockSize_sequences(), ZSTD_litLengthPrice(), and ZSTD_loadDEntropy().

LL_defaultNorm

const S16 LL_defaultNorm[MaxLL+1]

static

Initial value:

= { 4, 3, 2, 2, 2, 2, 2, 2,
                                             2, 2, 2, 2, 2, 1, 1, 1,
                                             2, 2, 2, 2, 2, 2, 2, 2,
                                             2, 3, 2, 1, 1, 1, 1, 1,
                                            -1,-1,-1,-1 }

Definition at line 194 of file zstd_internal.h.

Referenced by ZSTD_buildSuperBlockEntropy_sequences(), ZSTD_compressSequences_internal(), and ZSTD_estimateSubBlockSize_sequences().

LL_defaultNormLog

const U32 LL_defaultNormLog = LL_DEFAULTNORMLOG

static

Definition at line 200 of file zstd_internal.h.

Referenced by ZSTD_buildSuperBlockEntropy_sequences(), ZSTD_compressSequences_internal(), and ZSTD_estimateSubBlockSize_sequences().

ML_bits

const U32 ML_bits[MaxML+1]

static

Initial value:

= { 0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0,
                                      1, 1, 1, 1, 2, 2, 3, 3,
                                      4, 4, 5, 7, 8, 9,10,11,
                                     12,13,14,15,16 }

Definition at line 202 of file zstd_internal.h.

Referenced by ZSTD_encodeSequences_body(), ZSTD_estimateSubBlockSize_sequences(), ZSTD_getMatchPrice(), and ZSTD_loadDEntropy().

ML_defaultNorm

const S16 ML_defaultNorm[MaxML+1]

static

Initial value:

= { 1, 4, 3, 2, 2, 2, 2, 2,
                                             2, 1, 1, 1, 1, 1, 1, 1,
                                             1, 1, 1, 1, 1, 1, 1, 1,
                                             1, 1, 1, 1, 1, 1, 1, 1,
                                             1, 1, 1, 1, 1, 1, 1, 1,
                                             1, 1, 1, 1, 1, 1,-1,-1,
                                            -1,-1,-1,-1,-1 }

Definition at line 209 of file zstd_internal.h.

Referenced by ZSTD_buildSuperBlockEntropy_sequences(), ZSTD_compressSequences_internal(), and ZSTD_estimateSubBlockSize_sequences().

ML_defaultNormLog

const U32 ML_defaultNormLog = ML_DEFAULTNORMLOG

static

Definition at line 217 of file zstd_internal.h.

Referenced by ZSTD_buildSuperBlockEntropy_sequences(), ZSTD_compressSequences_internal(), and ZSTD_estimateSubBlockSize_sequences().

OF_defaultNorm

const S16 OF_defaultNorm[DefaultMaxOff+1]

static

Initial value:

= { 1, 1, 1, 1, 1, 1, 2, 2,
                                                     2, 1, 1, 1, 1, 1, 1, 1,
                                                     1, 1, 1, 1, 1, 1, 1, 1,
                                                    -1,-1,-1,-1,-1 }

Definition at line 219 of file zstd_internal.h.

Referenced by ZSTD_buildSuperBlockEntropy_sequences(), ZSTD_compressSequences_internal(), and ZSTD_estimateSubBlockSize_sequences().

OF_defaultNormLog

const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG

static

Definition at line 224 of file zstd_internal.h.

Referenced by ZSTD_buildSuperBlockEntropy_sequences(), ZSTD_compressSequences_internal(), and ZSTD_estimateSubBlockSize_sequences().

repStartValue

const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 }

static

Definition at line 142 of file zstd_internal.h.

Referenced by ZSTD_copyBlockSequences(), ZSTD_decompressBegin(), and ZSTD_reset_compressedBlockState().

ZSTD_blockHeaderSize

const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE

static

Definition at line 162 of file zstd_internal.h.

Referenced by ZSTD_buildSeqStore(), ZSTD_compress_frameChunk(), ZSTD_compressBlock_targetCBlockSize_body(), ZSTD_compressSubBlock(), ZSTD_CStreamOutSize(), ZSTD_decompressContinue(), ZSTD_decompressFrame(), ZSTD_decompressStream(), ZSTD_DStreamInSize(), ZSTD_estimateSubBlockSize(), ZSTD_findFrameSizeInfo(), ZSTD_getcBlockSize(), ZSTD_writeEpilogue(), and ZSTD_writeLastEmptyBlock().

ZSTD_did_fieldSize

const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 }

static

Definition at line 157 of file zstd_internal.h.

Referenced by ZSTD_frameHeaderSize_internal().

ZSTD_fcs_fieldSize

const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 }

static

Definition at line 156 of file zstd_internal.h.

Referenced by ZSTD_frameHeaderSize_internal().