/*

* All rights reserved.

*

* This source code is licensed under both the BSD-style license (found in the

#include "zstd_compress_internal.h" /* ZSTD_hashPtr, ZSTD_count, ZSTD_storeSeq */

#include "zstd_fast.h"

const void* const end,

ZSTD_dictTableLoadMethod_e dtlm)

{

const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;

const U32 fastHashFillStep = 3;

/* Always insert every fastHashFillStep position into the hash table.

* Insert the other positions if their hash entry is empty.

*/

} } } }

}

/*

* If you squint hard enough (and ignore repcodes), the search operation at any

*

* This is also the work we do at the beginning to enter the loop initially.

*/

void const* src, size_t srcSize,

{

const ZSTD_compressionParameters* const cParams = &ms->cParams;

U32* const hashTable = ms->hashTable;

U32 const hlog = cParams->hashLog;

const BYTE* const base = ms->window.base;

const BYTE* const istart = (const BYTE*)src;

const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);

U32 rep_offset1 = rep[0];

U32 rep_offset2 = rep[1];

size_t hash0; /* hash for ip0 */

size_t hash1; /* hash for ip1 */

U32 offcode;

const BYTE* match0;

size_t step;

const BYTE* nextStep;

const size_t kStepIncr = (1 << (kSearchStrength - 1));

DEBUGLOG(5, "ZSTD_compressBlock_fast_generic");

ip0 += (ip0 == prefixStart);

{ U32 const curr = (U32)(ip0 - base);

U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, cParams->windowLog);

U32 const maxRep = curr - windowLow;

}

/* start each op */

hash0 = ZSTD_hashPtr(ip0, hlog, mls);

hash1 = ZSTD_hashPtr(ip1, hlog, mls);

do {

/* load repcode match for ip[2]*/

mLength = ip0[-1] == match0[-1];

ip0 -= mLength;

match0 -= mLength;

mLength += 4;

goto _match;

}

goto _offset;

}

/* lookup ip[1] */

/* hash ip[2] */

hash0 = hash1;

current0 = (U32)(ip0 - base);

hashTable[hash0] = current0;

goto _offset;

}

/* lookup ip[1] */

/* hash ip[2] */

hash0 = hash1;

} while (ip3 < ilimit);

_cleanup:

* However, it seems to be a meaningful performance hit to try to search

* them. So let's not. */

/* save reps for next block */

/* Return the last literals size */

return (size_t)(iend - anchor);

_offset: /* Requires: ip0, idx */

/* Compute the offset code. */

rep_offset2 = rep_offset1;

rep_offset1 = (U32)(ip0-match0);

mLength = 4;

/* Count the backwards match length. */

ip0 += mLength;

anchor = ip0;

/* Fill table and check for immediate repcode. */

if (ip0 <= ilimit) {

/* Fill Table */

{ U32 const tmpOff = rep_offset2; rep_offset2 = rep_offset1; rep_offset1 = tmpOff; } /* swap rep_offset2 <=> rep_offset1 */

hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base);

ip0 += rLength;

anchor = ip0;

continue; /* faster when present (confirmed on gcc-8) ... (?) */

} } }

goto _start;

}

void const* src, size_t srcSize) \

{ \

}

ZSTD_GEN_FAST_FN(noDict, 4, 1)

ZSTD_GEN_FAST_FN(noDict, 7, 0)

size_t ZSTD_compressBlock_fast(

void const* src, size_t srcSize)

{

assert(ms->dictMatchState == NULL);

{

default: /* includes case 3 */

case 4 :

return ZSTD_compressBlock_fast_noDict_7_1(ms, seqStore, rep, src, srcSize);

}

} else {

{

default: /* includes case 3 */

case 4 :

case 7 :

return ZSTD_compressBlock_fast_noDict_7_0(ms, seqStore, rep, src, srcSize);

}

}

}

FORCE_INLINE_TEMPLATE

size_t ZSTD_compressBlock_fast_dictMatchState_generic(

void const* src, size_t srcSize, U32 const mls, U32 const hasStep)

{

const ZSTD_compressionParameters* const cParams = &ms->cParams;

U32 const stepSize = cParams->targetLength + !(cParams->targetLength);

const BYTE* const base = ms->window.base;

const BYTE* const istart = (const BYTE*)src;

const BYTE* anchor = istart;

const U32 prefixStartIndex = ms->window.dictLimit;

const BYTE* const prefixStart = base + prefixStartIndex;

const BYTE* const iend = istart + srcSize;

const BYTE* const ilimit = iend - HASH_READ_SIZE;

U32 offset_1=rep[0], offset_2=rep[1];

const ZSTD_compressionParameters* const dictCParams = &dms->cParams ;

const U32* const dictHashTable = dms->hashTable;

const U32 dictStartIndex = dms->window.dictLimit;

const BYTE* const dictStart = dictBase + dictStartIndex;

const BYTE* const dictEnd = dms->window.nextSrc;

const U32 dictIndexDelta = prefixStartIndex - (U32)(dictEnd - dictBase);

/* if a dictionary is still attached, it necessarily means that

* it is within window size. So we just check it. */

const U32 maxDistance = 1U << cParams->windowLog;

assert(endIndex - prefixStartIndex <= maxDistance);

(void)maxDistance; (void)endIndex; /* these variables are not used when assert() is disabled */

* when translating a dict index into a local index */

assert(prefixStartIndex >= (U32)(dictEnd - dictBase));

/* init */

DEBUGLOG(5, "ZSTD_compressBlock_fast_dictMatchState_generic");

/* dictMatchState repCode checks don't currently handle repCode == 0

* disabling. */

assert(offset_1 <= dictAndPrefixLength);

assert(offset_2 <= dictAndPrefixLength);

size_t mLength;

} /* catch up */

offset_2 = offset_1;

offset_1 = offset;

}

/* match found */

/* Fill Table */

assert(base+curr+2 > istart); /* check base overflow */

hashTable[ZSTD_hashPtr(base+curr+2, hlog, mls)] = curr+2; /* here because curr+2 could be > iend-8 */

/* check immediate repcode */

U32 const repIndex2 = current2 - offset_2;

const BYTE* repMatch2 = repIndex2 < prefixStartIndex ?

dictBase - dictIndexDelta + repIndex2 :

base + repIndex2;

const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;

U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */

continue;

}

break;

}

}

}

/* save reps for next block */

/* Return the last literals size */

return (size_t)(iend - anchor);

ZSTD_GEN_FAST_FN(dictMatchState, 7, 0)

size_t ZSTD_compressBlock_fast_dictMatchState(

void const* src, size_t srcSize)

{

U32 const mls = ms->cParams.minMatch;

}

void const* src, size_t srcSize, U32 const mls, U32 const hasStep)

{

const ZSTD_compressionParameters* const cParams = &ms->cParams;

U32* const hashTable = ms->hashTable;

U32 const hlog = cParams->hashLog;

/* support stepSize of 0 */

const BYTE* const base = ms->window.base;

const BYTE* const dictBase = ms->window.dictBase;

const BYTE* const istart = (const BYTE*)src;

const BYTE* anchor = istart;

const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);

const U32 lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);

const BYTE* const iend = istart + srcSize;

const BYTE* const ilimit = iend - 8;

U32 offset_1=rep[0], offset_2=rep[1];

(void)hasStep; /* not currently specialized on whether it's accelerated */

if (prefixStartIndex == dictStartIndex)

return ZSTD_compressBlock_fast(ms, seqStore, rep, src, srcSize);

}

} }

/* save reps for next block */

/* Return the last literals size */

return (size_t)(iend - anchor);

}

ZSTD_GEN_FAST_FN(extDict, 4, 0)

ZSTD_GEN_FAST_FN(extDict, 7, 0)

size_t ZSTD_compressBlock_fast_extDict(

void const* src, size_t srcSize)

{

U32 const mls = ms->cParams.minMatch;

switch(mls)

{

default: /* includes case 3 */