/*

* All rights reserved.

*

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

#include "zstd_compress_internal.h"

#include "zstd_lazy.h"

/*-*************************************

* Binary Tree search

***************************************/

const BYTE* ip, const BYTE* iend,

U32 mls)

{

* sort one already inserted but unsorted position

* assumption : curr >= btlow == (curr - btmask)

* doesn't fail */

U32 curr, const BYTE* inputEnd,

U32 nbCompares, U32 btLow,

const ZSTD_dictMode_e dictMode)

}

const BYTE* const ip, const BYTE* const iend,

size_t* offsetPtr,

size_t bestLength,

U32 const mls,

const ZSTD_dictMode_e dictMode)

{

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

const U32 * const dictHashTable = dms->hashTable;

U32 const hashLog = dmsCParams->hashLog;

U32 matchIndex = dictMatchIndex + dictIndexDelta;

if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {

DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",

}

if (ip+matchLength == iend) { /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */

break; /* drop, to guarantee consistency (miss a little bit of compression) */

}

if (bestLength >= MINMATCH) {

DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",

curr, (U32)bestLength, (U32)*offsetPtr, mIndex);

}

}

const BYTE* const ip, const BYTE* const iend,

U32 const mls,

const ZSTD_dictMode_e dictMode)

{

if (matchLength > bestLength) {

if (matchLength > matchEndIdx - matchIndex)

matchEndIdx = matchIndex + (U32)matchLength;

if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */

if (dictMode == ZSTD_dictMatchState) {

nbCompares = 0; /* in addition to avoiding checking any

if (dictMode == ZSTD_dictMatchState && nbCompares) {

bestLength = ZSTD_DUBT_findBetterDictMatch(

ms, ip, iend,

mls, dictMode);

}

assert(matchEndIdx > curr+8); /* ensure nextToUpdate is increased */

ms->nextToUpdate = matchEndIdx - 8; /* skip repetitive patterns */

if (bestLength >= MINMATCH) {

DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",

}

return bestLength;

}

/* ZSTD_BtFindBestMatch() : Tree updater, providing best match */

const BYTE* const ip, const BYTE* const iLimit,

const U32 mls /* template */,

const ZSTD_dictMode_e dictMode)

{

DEBUGLOG(7, "ZSTD_BtFindBestMatch");

if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */

ZSTD_updateDUBT(ms, ip, iLimit, mls);

}

/* *********************************

* Dedicated dict search

***********************************/

{

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

U32 const target = (U32)(ip - base);

*/

FORCE_INLINE_TEMPLATE

size_t ZSTD_dedicatedDictSearch_lazy_search(size_t* offsetPtr, size_t ml, U32 nbAttempts,

const BYTE* const ip, const BYTE* const iLimit,

const BYTE* const prefixStart, const U32 curr,

const U32 dictLimit, const size_t ddsIdx) {

/* save best solution */

if (currentMl > ml) {

ml = currentMl;

if (ip+currentMl == iLimit) {

/* best possible, avoids read overflow on next attempt */

return ml;

/* save best solution */

if (currentMl > ml) {

ml = currentMl;

if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */

}

}

/* Update chains up to ip (excluded)

Assumption : always within prefix (i.e. not within extDict) */

const ZSTD_compressionParameters* const cParams,

{

U32* const hashTable = ms->hashTable;

const U32 hashLog = cParams->hashLog;

NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];

hashTable[h] = idx;

idx++;

}

ms->nextToUpdate = target;

return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];

}

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

}

/* inlining is important to hardwire a hot branch (template emulation) */

FORCE_INLINE_TEMPLATE

size_t ZSTD_HcFindBestMatch(

const BYTE* const ip, const BYTE* const iLimit,

size_t* offsetPtr,

const U32 mls, const ZSTD_dictMode_e dictMode)

U32 nbAttempts = 1U << cParams->searchLog;

size_t ml=4-1;

const U32 ddsHashLog = dictMode == ZSTD_dedicatedDictSearch

? dms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG : 0;

const size_t ddsIdx = dictMode == ZSTD_dedicatedDictSearch

}

/* HC4 match finder */

for ( ; (matchIndex>=lowLimit) & (nbAttempts>0) ; nbAttempts--) {

size_t currentMl=0;

if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {

const BYTE* const match = base + matchIndex;

assert(matchIndex >= dictLimit); /* ensures this is true if dictMode != ZSTD_extDict */

currentMl = ZSTD_count(ip, match, iLimit);

} else {

const BYTE* const match = dictBase + matchIndex;

/* save best solution */

if (currentMl > ml) {

ml = currentMl;

if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */

}

if (currentMl > ml) {

ml = currentMl;

assert(curr > matchIndex + dmsIndexDelta);

if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */

}

* (SIMD) Row-based matchfinder

***********************************/

/* Constants for row-based hash */

#define ZSTD_ROW_HASH_TAG_MASK ((1u << ZSTD_ROW_HASH_TAG_BITS) - 1)

#define ZSTD_ROW_HASH_MAX_ENTRIES 64 /* absolute maximum number of entries per row, for all configurations */

* Starting from the LSB, returns the idx of the next non-zero bit.

* Basically counting the nb of trailing zeroes.

*/

}

/* ZSTD_row_nextIndex():

* Returns the next index to insert at within a tagTable row, and updates the "head"

*/

FORCE_INLINE_TEMPLATE U32 ZSTD_row_nextIndex(BYTE* const tagRow, U32 const rowMask) {

}

/* ZSTD_isAligned():

/* ZSTD_row_prefetch():

* Performs prefetching for the hashTable and tagTable at a given row.

*/

PREFETCH_L1(hashTable + relRow);

if (rowLog >= 5) {

PREFETCH_L1(hashTable + relRow + 16);

* Fill up the hash cache starting at idx, prefetching up to ZSTD_ROW_HASH_CACHE_SIZE entries,

* but not beyond iLimit.

*/

U32 const rowLog, U32 const mls,

U32 idx, const BYTE* const iLimit)

{

U32 const* const hashTable = ms->hashTable;

U32 const hashLog = ms->rowHashLog;

U32 const maxElemsToPrefetch = (base + idx) > iLimit ? 0 : (U32)(iLimit - (base + idx) + 1);

U32 const lim = idx + MIN(ZSTD_ROW_HASH_CACHE_SIZE, maxElemsToPrefetch);

for (; idx < lim; ++idx) {

U32 const row = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;

ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);

ms->hashCache[idx & ZSTD_ROW_HASH_CACHE_MASK] = hash;

* Returns the hash of base + idx, and replaces the hash in the hash cache with the byte at

* base + idx + ZSTD_ROW_HASH_CACHE_SIZE. Also prefetches the appropriate rows from hashTable and tagTable.

*/

U32 idx, U32 const hashLog,

{

U32 const row = (newHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;

ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);

{ U32 const hash = cache[idx & ZSTD_ROW_HASH_CACHE_MASK];

/* ZSTD_row_update_internalImpl():

* Updates the hash table with positions starting from updateStartIdx until updateEndIdx.

*/

{

U32* const hashTable = ms->hashTable;

U32 const hashLog = ms->rowHashLog;

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

DEBUGLOG(6, "ZSTD_row_update_internalImpl(): updateStartIdx=%u, updateEndIdx=%u", updateStartIdx, updateEndIdx);

for (; updateStartIdx < updateEndIdx; ++updateStartIdx) {

U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;

U32* const row = hashTable + relRow;

U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);

row[pos] = updateStartIdx;

}

}

* Inserts the byte at ip into the appropriate position in the hash table, and updates ms->nextToUpdate.

* Skips sections of long matches as is necessary.

*/

{

U32 idx = ms->nextToUpdate;

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

* External wrapper for ZSTD_row_update_internal(). Used for filling the hashtable during dictionary

* processing.

*/

const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);

const U32 rowMask = (1u << rowLog) - 1;

const U32 mls = MIN(ms->cParams.minMatch, 6 /* mls caps out at 6 */);

DEBUGLOG(5, "ZSTD_row_update(), rowLog=%u", rowLog);

}

#if defined(ZSTD_ARCH_X86_SSE2)

}

#endif

FORCE_INLINE_TEMPLATE ZSTD_VecMask

{

assert((rowEntries == 16) || (rowEntries == 32) || rowEntries == 64);

assert(rowEntries <= ZSTD_ROW_HASH_MAX_ENTRIES);

#if defined(ZSTD_ARCH_X86_SSE2)

#else /* SW or NEON-LE */

# if defined(ZSTD_ARCH_ARM_NEON)

/* This NEON path only works for little endian - otherwise use SWAR below */

if (MEM_isLittleEndian()) {

}

# endif /* ZSTD_ARCH_ARM_NEON */

/* SWAR */

const size_t shiftAmount = ((chunkSize * 8) - chunkSize);

const size_t xFF = ~((size_t)0);

const size_t x01 = xFF / 0xFF;

}

matches = ~matches;

if (rowEntries == 16) {

} else if (rowEntries == 32) {

} else {

}

}

#endif

/* The high-level approach of the SIMD row based match finder is as follows:

* - Figure out where to insert the new entry:

* which row to insert into.

* generate a bitfield that we can cycle through to check the collisions in the hash table.

* - Pick the longest match.

*/

FORCE_INLINE_TEMPLATE

size_t ZSTD_RowFindBestMatch(

const BYTE* const ip, const BYTE* const iLimit,

size_t* offsetPtr,

const U32 mls, const ZSTD_dictMode_e dictMode,

const U32 rowLog)

{

U32* const hashTable = ms->hashTable;

U32* const hashCache = ms->hashCache;

const U32 hashLog = ms->rowHashLog;

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

const U32 rowEntries = (1U << rowLog);

const U32 rowMask = rowEntries - 1;

const U32 cappedSearchLog = MIN(cParams->searchLog, rowLog); /* nb of searches is capped at nb entries per row */

U32 nbAttempts = 1U << cappedSearchLog;

size_t ml=4-1;

/* DMS/DDS variables that may be referenced laster */

/* Initialize the following variables to satisfy static analyzer */

size_t ddsIdx = 0;

if (dictMode == ZSTD_dictMatchState) {

/* Prefetch DMS rows */

U32* const dmsHashTable = dms->hashTable;

U32 const dmsHash = (U32)ZSTD_hashPtr(ip, dms->rowHashLog + ZSTD_ROW_HASH_TAG_BITS, mls);

U32 const dmsRelRow = (dmsHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;

dmsTag = dmsHash & ZSTD_ROW_HASH_TAG_MASK;

}

/* Update the hashTable and tagTable up to (but not including) ip */

{ /* Get the hash for ip, compute the appropriate row */

U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;

U32 const tag = hash & ZSTD_ROW_HASH_TAG_MASK;

U32* const row = hashTable + relRow;

BYTE* tagRow = (BYTE*)(tagTable + relRow);

U32 matchBuffer[ZSTD_ROW_HASH_MAX_ENTRIES];

size_t numMatches = 0;

size_t currMatch = 0;

/* Cycle through the matches and prefetch */

U32 const matchIndex = row[matchPos];

assert(numMatches < rowEntries);

if (matchIndex < lowLimit)

break;

PREFETCH_L1(dictBase + matchIndex);

}

matchBuffer[numMatches++] = matchIndex;

}

/* Speed opt: insert current byte into hashtable too. This allows us to avoid one iteration of the loop

in ZSTD_row_update_internal() at the next search. */

{

U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);

row[pos] = ms->nextToUpdate++;

}

if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {

const BYTE* const match = base + matchIndex;

assert(matchIndex >= dictLimit); /* ensures this is true if dictMode != ZSTD_extDict */

currentMl = ZSTD_count(ip, match, iLimit);

} else {

const BYTE* const match = dictBase + matchIndex;

/* Save best solution */

if (currentMl > ml) {

ml = currentMl;

if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */

}

}

const U32 dmsSize = (U32)(dmsEnd - dmsBase);

const U32 dmsIndexDelta = dictLimit - dmsSize;

U32 matchBuffer[ZSTD_ROW_HASH_MAX_ENTRIES];

size_t numMatches = 0;

size_t currMatch = 0;

U32 const matchIndex = dmsRow[matchPos];

if (matchIndex < dmsLowestIndex)

break;

PREFETCH_L1(dmsBase + matchIndex);

matchBuffer[numMatches++] = matchIndex;

}

/* Return the longest match */

if (currentMl > ml) {

ml = currentMl;

assert(curr > matchIndex + dmsIndexDelta);

if (ip+currentMl == iLimit) break;

}

}

* ZSTD_searchMax() dispatches to the correct implementation function.

*

* TODO: The start of the search function involves loading and calculating a

* done in an initialization function, and saved somewhere in the match state.

* Then we could pass a pointer to the saved state instead of the match state,

* and avoid duplicate computations.

#define GEN_ZSTD_BT_SEARCH_FN(dictMode, mls) \

ZSTD_SEARCH_FN_ATTRS size_t ZSTD_BT_SEARCH_FN(dictMode, mls)( \

const BYTE* ip, const BYTE* const iLimit, \

size_t* offBasePtr) \

{ \

#define GEN_ZSTD_HC_SEARCH_FN(dictMode, mls) \

ZSTD_SEARCH_FN_ATTRS size_t ZSTD_HC_SEARCH_FN(dictMode, mls)( \

const BYTE* ip, const BYTE* const iLimit, \

size_t* offsetPtr) \

{ \

#define GEN_ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog) \

ZSTD_SEARCH_FN_ATTRS size_t ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog)( \

const BYTE* ip, const BYTE* const iLimit, \

size_t* offsetPtr) \

{ \

* If a match is found its offset is stored in @p offsetPtr.

*/

FORCE_INLINE_TEMPLATE size_t ZSTD_searchMax(

const BYTE* ip,

const BYTE* iend,

size_t* offsetPtr,

* Common parser - lazy strategy

*********************************/

U32 rep[ZSTD_REP_NUM],

const void* src, size_t srcSize,

const searchMethod_e searchMethod, const U32 depth,

const U32 mls = BOUNDED(4, ms->cParams.minMatch, 6);

const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);

const int isDMS = dictMode == ZSTD_dictMatchState;

const int isDDS = dictMode == ZSTD_dedicatedDictSearch;

const int isDxS = isDMS || isDDS;

const U32 dictLowestIndex = isDxS ? dms->window.dictLimit : 0;

const BYTE* const dictBase = isDxS ? dms->window.base : NULL;

const BYTE* const dictLowest = isDxS ? dictBase + dictLowestIndex : NULL;

U32 const curr = (U32)(ip - base);

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

U32 const maxRep = curr - windowLow;

}

if (isDxS) {

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

assert(offset_2 <= dictAndPrefixLength);

}

if (searchMethod == search_rowHash) {

}

/* Match Loop */

#endif

while (ip < ilimit) {

size_t matchLength=0;

const BYTE* start=ip+1;

DEBUGLOG(7, "search baseline (depth 0)");

&& repIndex < prefixLowestIndex) ?

dictBase + (repIndex - dictIndexDelta) :

base + repIndex;

&& (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {

const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;

matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;

}

/* first search (depth 0) */

if (ml2 > matchLength)

}

if (matchLength < 4) {

continue;

}

DEBUGLOG(7, "search depth 1");

ip ++;

if ( (dictMode == ZSTD_noDict)

size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;

int const gain2 = (int)(mlRep * 3);

if ((mlRep >= 4) && (gain2 > gain1))

}

if (isDxS) {

const U32 repIndex = (U32)(ip - base) - offset_1;

const BYTE* repMatch = repIndex < prefixLowestIndex ?

dictBase + (repIndex - dictIndexDelta) :

base + repIndex;

&& (MEM_read32(repMatch) == MEM_read32(ip)) ) {

const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;

size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;

int const gain2 = (int)(mlRep * 3);

if ((mlRep >= 4) && (gain2 > gain1))

}

}

if ((ml2 >= 4) && (gain2 > gain1)) {

continue; /* search a better one */

} }

DEBUGLOG(7, "search depth 2");

ip ++;

if ( (dictMode == ZSTD_noDict)

size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;

int const gain2 = (int)(mlRep * 4);

if ((mlRep >= 4) && (gain2 > gain1))

}

if (isDxS) {

const U32 repIndex = (U32)(ip - base) - offset_1;

const BYTE* repMatch = repIndex < prefixLowestIndex ?

dictBase + (repIndex - dictIndexDelta) :

base + repIndex;

&& (MEM_read32(repMatch) == MEM_read32(ip)) ) {

const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;

size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;

int const gain2 = (int)(mlRep * 4);

if ((mlRep >= 4) && (gain2 > gain1))

}

}

if ((ml2 >= 4) && (gain2 > gain1)) {

continue;

} } }

break; /* nothing found : store previous solution */

* notably if `value` is unsigned, resulting in a large positive `-value`.

*/

/* catch up */

if (dictMode == ZSTD_noDict) {

{ start--; matchLength++; }

}

if (isDxS) {

const BYTE* match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta : base + matchIndex;

const BYTE* const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest;

while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; } /* catch up */

}

}

/* store sequence */

_storeSequence:

{ size_t const litLength = (size_t)(start - anchor);

anchor = ip = start + matchLength;

}

/* check immediate repcode */

if (isDxS) {

const BYTE* repMatch = repIndex < prefixLowestIndex ?

dictBase - dictIndexDelta + repIndex :

base + repIndex;

&& (MEM_read32(repMatch) == MEM_read32(ip)) ) {

const BYTE* const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend;

matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd2, prefixLowest) + 4;

ip += matchLength;

anchor = ip;

continue;

&& (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {

/* store sequence */

matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;

ip += matchLength;

anchor = ip;

continue; /* faster when present ... (?) */

} } }

/* Return the last literals size */

return (size_t)(iend - anchor);

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

size_t ZSTD_compressBlock_lazy2_dedicatedDictSearch_row(

void const* src, size_t srcSize)

{

return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2, ZSTD_dedicatedDictSearch);

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

FORCE_INLINE_TEMPLATE

size_t ZSTD_compressBlock_lazy_extDict_generic(

U32 rep[ZSTD_REP_NUM],

const void* src, size_t srcSize,

const searchMethod_e searchMethod, const U32 depth)

DEBUGLOG(5, "ZSTD_compressBlock_lazy_extDict_generic (searchFunc=%u)", (U32)searchMethod);

/* init */

ip += (ip == prefixStart);

if (searchMethod == search_rowHash) {

}

/* Match Loop */

#endif

while (ip < ilimit) {

size_t matchLength=0;

const BYTE* start=ip+1;

U32 curr = (U32)(ip-base);

const U32 repIndex = (U32)(curr+1 - offset_1);

const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;

const BYTE* const repMatch = repBase + repIndex;

& (offset_1 <= curr+1 - windowLow) ) /* note: we are searching at curr+1 */

if (MEM_read32(ip+1) == MEM_read32(repMatch)) {

/* repcode detected we should take it */

} }

/* first search (depth 0) */

if (ml2 > matchLength)

}

if (matchLength < 4) {

continue;

}

ip ++;

curr++;

/* check repCode */

const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog);

const U32 repIndex = (U32)(curr - offset_1);

const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;

const BYTE* const repMatch = repBase + repIndex;

& (offset_1 <= curr - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */

if (MEM_read32(ip) == MEM_read32(repMatch)) {

/* repcode detected */

const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;

size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;

int const gain2 = (int)(repLength * 3);

if ((repLength >= 4) && (gain2 > gain1))

} }

/* search match, depth 1 */

if ((ml2 >= 4) && (gain2 > gain1)) {

continue; /* search a better one */

} }

ip ++;

curr++;

/* check repCode */

const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog);

const U32 repIndex = (U32)(curr - offset_1);

const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;

const BYTE* const repMatch = repBase + repIndex;

& (offset_1 <= curr - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */

if (MEM_read32(ip) == MEM_read32(repMatch)) {

/* repcode detected */

const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;

size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;

int const gain2 = (int)(repLength * 4);

if ((repLength >= 4) && (gain2 > gain1))

} }

/* search match, depth 2 */

if ((ml2 >= 4) && (gain2 > gain1)) {

continue;

} } }

break; /* nothing found : store previous solution */

}

/* catch up */

const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;

const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;

while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; } /* catch up */

}

/* store sequence */

_storeSequence:

{ size_t const litLength = (size_t)(start - anchor);

anchor = ip = start + matchLength;

}

/* check immediate repcode */

while (ip <= ilimit) {

const U32 repIndex = repCurrent - offset_2;

const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;

const BYTE* const repMatch = repBase + repIndex;

& (offset_2 <= repCurrent - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */

if (MEM_read32(ip) == MEM_read32(repMatch)) {

/* repcode detected we should take it */

const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;

matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;

ip += matchLength;

anchor = ip;

continue; /* faster when present ... (?) */

/* Return the last literals size */

return (size_t)(iend - anchor);

}

size_t ZSTD_compressBlock_greedy_extDict(

void const* src, size_t srcSize)

{

return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0);

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}

void const* src, size_t srcSize)

{

}