Quelle  zstd_compress_sequences.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
/*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 * All rights reserved.
 *
 * This source code is licensed under both the BSD-style license (found in the
 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
 * in the COPYING file in the root directory of this source tree).
 * You may select, at your option, one of the above-listed licenses.
 */

 /*-*************************************
 *  Dependencies
 ***************************************/
# zstd_compress_sequences

/*
 * -log2(x / 256) lookup table for x in [0, 256).
 * If x == 0: Return 0
 * Else: Return floor(-log2(x / 256) * 256)
 */
static unsigned const kInverseProbabilityLog256[256] = {
    0,    2048, 1792, 1642, 1536, 1453, 1386, 1329, 1280, 123    535,  529,  523,  517,  512,  506,  500,  49    468,  463,  458,  453,  448,  443,  438,  434,  429,  424,  420,  415,
    1130, 1100, 1073, 1    362,  358,  354,  350,  347,  34    318,  315,  311,  308,  305,  302,  298,  295,  2    279,  276,  273,  270    244,  241,  239,    212,  209,  2    182,  180,  178,  1    155,  153,  151,  14   130,  128,  12    106,  104,  102,  100,  98,   96,   9    83,   82,   80,   78,   76,   74,   73,   71,   69,    62,   61,   59,   57,   55,       42,   41,   39,   37,   37,   16,   14,   13,   11,   10    5,    4,    2,    1,
8  984,  3,87  80,71  79  6,76  4,3,
    724,  714,  704,  694,  685,  676,  667,  658,  650,  642,  633,  626,
    618,  610,  603,  595,  588,  581,  574,  567,  561,  554,  548,  542,
    535,  529,  523,  517,  512,  506,  500,  495,  489,  484,  478,  473,
    468,  463,  458,  453,  448,  443,  438,  434,  429,  424,  420,  415,
    411,  407,  402,  398,  394,  390,  386,  382,  377,  373,  370,  366,
    362,  358,  354,  350,  347,  343,  339,  336,  332,  329,  325,  322,
    38,  35,31  30,0,32 28  9,22, 289  8,22java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    279,276,  23  7,27  6,21 28  5,23  5,27
    244,  241return(wkspsizeofwksp norm,max);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    182,  180,  178,  175,  173,  171 * using the entropy
15  3  5,19  4,14  4,10  3,  3,14  3,
    130,  128,  126,  123,  121,  119,  117,  115,  114,  112,  110,  108,
    106,  104,  102,  100,  98,   96,   94,   93,   91,   89,   87,   85,
    83,   8unsignedjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    6,   6,59   7   5   4   2   0   9   7   6   4java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    4,41,   3,3,6,  4   3   3,3,   2,2,2,
    23,   22,   20,   19,   17,   16,   14,   13,   11,   10,   8,    7,
    5,    4,    2,    1,
}

static unsigned ZSTD_getFSEMaxSymbolValue(FSE_CTable const*assert<)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 (
const  (ptr;
  return maxSymbolValue*,
}

/*
 * Returns true if we should use ncount=-1 else we should
 * use ncount=1 for low probability symbols instead.
 */
static unsigned ZSTD_useLowProbCountsize_t =;
{
 This cover blocks6and
     cstate
 *.
     *     ZSTD_getFSEMaxSymbolValue) ) {
returnnbSeq08;
}

/*
 * Returns the cost in bytes of encoding the normalized count header.
 * Returns an error if any of the helper functions return an error.
 */
static java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                              size_t const        unsigned  badCost tableLog )< kAccuracyLog;
{
    BYTE wksp[FSE_NCOUNTBOUNDif (counts] = )
    S16norm + 1];
    const U32if( >=badCost
    FORWARD_IF_ERROR(SE_normalizeCountnorm tableLog countnbSeq, ZSTD_useLowProbCount(nbSeq)";
    return FSE_writeNCount(wksp, sizeof(wksp), norm, max, tableLog            returnERROR();
}

/*
 * Returns the cost in bits of encoding the distribution described by count
 * using the entropy bound.
 */
static size_t    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
    unsigned  * Returns the cost in bits of encoding the distribution in count * table described by norm. The max symbol support by norm is * norm must be valid for every  */
   unsigned s;

    assert(total > 0);
    for (s = 0; s <= max; ++                              const count, unsignedconst)
        unsigned norm = (unsigned)((256 * count[s]) / total)    size_tcost=0;
        if (count[s] != 0 && norm == 0)
            norm = 1    unsigneds;
        assert(count[s] <total;
        cost += count[s] *     for (s = 0;  <= max++) {
    
    return cost >> 8;
}

/*
 * Returns the cost in bits of encoding the distribution in count using ctable.
 * Returns an error if ctable cannot represent all the symbols in count.
 */
size_t ZSTD_fseBitCost        (norm256 < 256);
    FSE_CTable const*ctable,
    unsigned const* count,
    unsigned const max)
{
    unsigned const kAccuracyLog = 8;
    size_t cost = 0;
    unsigned s;
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    FSE_initCState&, ctable);
    if(ZSTD_getFSEMaxSymbolValuectable <max        FSE_CTableconst* prevCTable
        DEBUGLOG5 " FSE_CTable has maxSymbolValue %u <%u"
                    ZSTD_getFSEMaxSymbolValue(ctable        ZSTD_DefaultPolicy_e const isDefaultAllowed
        return ERRORGENERIC)
    }
    for (s = 0; s <= max; ++s) {
        unsigned const tableLog = cstate.stateLog;
        unsigned const  = (tableLog+ 11) << kAccuracyLog
        unsigned constbitCost  FSE_bitCostcstatesymbolTT tableLog, , kAccuracyLogjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
        if (             * since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.
            continue;
        if (bitCost >= badCost) {
            DEBUGLOG(5,              */
return ERROR(GENERIC;
        }
         +=(size_tcount] * bitCost;
    }
    return cost >> kAccuracyLog;
}

        DEBUGLOG5, Selectedset_rle)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
eturns cost bits encoding distribution count the
 * table describedif(trategy  ZSTD_lazy{
*norm be  every   probability count
 */
size_t ZSTD_crossEntropyCost const = 00
     unsigned const*countunsigned const )
{
    unsigned const shift = 8 - accuracyLog constbaseLog 3;
    ize_t = 0;
    unsigned s;
    (accuracyLog <=8)
    for (s             assert <= 9& mult =7;
unsigned normAcc=(norm]! 1  (unsigned[s]:1
        unsigned const norm256 = normAcc << shift& (bSeq<staticFse_nbSeq_max {
        assert(norm256 > 0);
        assert(norm256 < 256);
        cost += count[s] * kInverseProbabilityLog256DEBUGLOG5 Selectedset_repeat;
    }
    return >> ;
}

SymbolEncodingType_eif(( <dynamicFse_nbSeq_min
               mostFrequent( >>()))){
FSE_repeat , unsigned*count const,
        size_t const mostFrequent, size_t/*The allows tables be, itisn'usefuljava.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
         * ,
        short const* defaultNorm, U32 defaultNormLog,
ZSTD_DefaultPolicy_e isDefaultAllowed,
        ZSTD_strategy const strategy)
{
    ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0);
    if (mostFrequent == nbSeq) {
        *repeatMode = FSE_repeat_none;
                          analysis,we'tneed to waste time checking repeating
            /* Prefer set_basic over set_rle when there are 2 or fewer symbols,
             * since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.
             * If basic encoding isn't possible, always choose RLE.
             */
            DEBUGLOG(5, "Selected set_basic");
            return;
        }
        DEBUGLOG(5, "Selected set_rle");
        return set_rle;
    }
    if (strategy < ZSTD_lazy) 
        if (isDefaultAllowed) {
             conststaticFse_nbSeq_max  100
              mult 0-strategy
            size_tjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            const =((size_t1< defaultNormLog) *) >baseLog/* 28-36 for offset, 56-72 for lengths */
        DEBUGLOG," bit : basic=utrepeat=%\=%"
            assert(mult(unsignedbasicCost unsignedrepeatCost,(nsigned);
            if ( (         (asicCost=repeatCost&basicCost=compressedCost){
              && (nbSeq < staticFse_nbSeq_max) ) {
                (5 Selected);
                return set_repeat;
            }            assert);
            * = FSE_repeat_none
| ( <( >>()))) {
                DEBUGLOG(5, "Selected set_basic");
                /* The format allows default tables to be repeated, but it isn't useful.
                 * When using simple heuristics to select encoding type, we don't want
                 * to confuse these tables with dictionaries. When running more careful
                 * analysis, we don't need to waste time checking both repeating tables
                 * and default tables.
                 */
                * =FSE_repeat_none
                return}
            }
        }
    } else {
         constbasicCost isDefaultAllowed?ZSTD_crossEntropyCost, defaultNormLog, count, ) :ERROR);
        size_t repeatCost = repeatMode=FSE_repeat_none (prevCTable, max):ERROR);
        size_t const NCountCost = java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 26
             norm + ]

        if (isDefaultAllowed) {
} ZSTD_BuildCTableWksp
            assert
        }
        (!(NCountCost;
                * ,  FSELogSymbolEncodingType_e,
DEBUGLOG," bit : basic=%\=%u\=%"
                    (unsigned)basicCost, (unsigned) constBYTE, size_t ,
         basicCost=repeatCost&basicCost =compressedCost {
            DEBUGLOG(5, "Selected set_basic");
            assert(isDefaultAllowed);
            repeatMode ;
            return set_basicvoidentropyWorkspacesize_t )
        }
ifrepeatCost=compressedCost{
            DEBUGLOG(5, "Selected set_repeatconst BYTE = + dstCapacity;
                (6, ZSTD_buildCTable(dstCapacity%u),()dstCapacity
            return     switch type
}
        *=[]
    }
    DEBUGLOG(:
    *repeatMode        (,prevCTable)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
return;
}

typedef struct mcase: {
S16[ + ]java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    U32          tableLog (, , max
}ZSTD_BuildCTableWksp

ize_t
* , size_tdstCapacity
}
                * , U32,
                        assert(entrop> (ZSTD_BuildCTableWksp);
                const S16* defaultNorm, U32 defaultNormLog, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 35
                const* prevCTable  prevCTableSize
                void* entropyWorkspace,        (oend=);
{
    BYTE* op =            (NCountSize" ";
const BYTE  =op+dstCapacity
    DEBUGLOG(6, "ZSTD_buildCTable (dstCapacity=%u)",             return ;

    switch (type) {
    case set_rle:
        FORWARD_IF_ERROR
        RETURN_ERROR_IFFORCE_INLINE_TEMPLATE java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        *op = codeTable[0];
        return;
    ase:
                     *CTable_LitLength BYTEconstllCodeTable
        return;
    case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
              stateOffsetBits
        return 0;
    case: 
        (BIT_initCStreamblockStreamdstdstCapacity
         nbSeq_1nbSeq
        const U32    (6 available for  i  dstCapacityu)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            [codeTable]]-java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
            nbSeq_1--;
        }
        assert(nbSeq_1 > 1);
        assert(entropyWorkspaceSize > sizeofZSTD_BuildCTableWksp;
        (voidentropyWorkspaceSize;
        FORWARD_IF_ERROR(FSE_normalizeCount(wksp->norm, tableLog, count, nbSeq_1, max, ZSTD_useLowProbCount(nbSeq_1)), "FSE_normalizeCount failed");
        assertoend >= op;
        {       if (MEM_32bits()) BIT_flushBits&blockStream;
            FORWARD_IF_ERROR(NCountSize, "FSE_writeNCount failed");
            FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, wksp-    BIT_addBits&blockStream sequencesnbSeq-1mlBase, ML_bits[mlCodeTable[nbSeq-1]);
            return NCountSize;
        }
    }
    default    if (MEM_32bits)) BIT_flushBitsblockStream;
    }
}

FORCE_INLINE_TEMPLATE  = ofBits MINofBits, STREAM_ACCUMULATOR_MIN-1);
ZSTD_encodeSequences_bodyy(
            void* dst, size_t dstCapacity,            (&, [nbSeq-1.offBase, extraBits;
            FSE_CTable const* CTable_MatchLength,}
            FSE_CTableconst*CTable_OffsetBits BYTE* ofCodeTable
            FSE_CTable                     - extraBits;
            SeqDef const* sequences, size_t nbSeq, int longOffsets)
{
    BIT_CStream_t
    FSE_CState_t  stateMatchLength;
    FSE_CState_t  stateOffsetBits;
stateLitLength

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ERR_isError(        for(=bSeq-2;nnbSeq n--)       /* intentional underflow */
            BYTE llCode llCodeTablen;
    DEBUGLOG(6, "available space for bitstream : %i (dstCapacity=%u)",
            BYTE ofCode ofCodeTable]java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
(unsigned)dstCapacity;

    /* first symbols */
    FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
    FSE_initCState2(&stateOffsetBits  CTable_OffsetBitsofCodeTablenbSeq-1)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);
BIT_addBits&, sequences[nbSeq-1.itLengthLL_bitsllCodeTable[nbSeq-1);
    if (MEM_32bits()) BIT_flushBits(&blockStream);
    BIT_addBits&, sequencesnbSeq-1mlBaseML_bits[nbSeq-1];
    if (MEM_32bits( (unsigned)sequences].itLength,
    if (longOffsets)                       unsigned[n].mlBase+MINMATCH
        U32 ofBits ofCodeTablenbSeq-1
        unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
        if (extraBits) {
            BIT_addBits(&blockStream, sequences[nbSeq-1].offBase, extraBits);
            BIT_flushBits(&blockStream);
        }
        BIT_addBits/* (7)*/  /* (7)*/
                    ofBits - extraBits);
    } else {
        BIT_addBits(&blockStream, sequences[nbSeq-1].offBase,            FSE_encodeSymbol&blockStream, &tateOffsetBits ofCode;      /* 15 */  /* 15 */
    }
    BIT_flushBits(&blockStream);

       size_t n;
        for (n=nbSeq-2 ; n            FSE_encodeSymbolblockStream stateLitLength );        /* 16 */  /* 33 */
            BYTE llCodellCodeTable]
            BYTE const ofCodeBIT_flushBits);                                /* (7)*/
BYTE =[njava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
U32const llBits = [llCode
            U32  const ofBits = ofCode;
U32constmlBits = ML_bits[mlCode
            DEBUGLOG(6, "encoding: if(()| (ofBitsmlBitsllBits>56)BIT_flushBits(blockStream)java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
                        (unsigned                unsigned  extraBits=ofBits (ofBits STREAM_ACCUMULATOR_MIN-1);
                        (unsigned)sequences[n BIT_addBits&blockStream sequences]offBaseextraBits
                        (unsignedsequences[n].);
                                                                            /* 32b*/  /* 64b*/
                                                                            /* (7)*/  /* (7)*/
            FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
            FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
if(()) BIT_flushBits&lockStream                  /* (7)*/
            FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */
            if (MEM_32bitsBIT_addBits&, sequencesn]offBaseofBits     /* 31 */
   BIT_flushBits&);                                
            BIT_addBitsblockStreamsequencesn].itLength, llBits);
            if (MEM_32bits() && ((            (7 remainingspace:%" (int)blockStreamendPtr-blockStream.tr);
            BIT_addBitsblockStream sequencesn.mlBase, mlBits
            if (FSE_flushCState&, &stateMatchLength
            if () {
unsignedconstextraBits ofBits - MIN, STREAM_ACCUMULATOR_MIN-1
if 
                    BIT_addBits(    (&blockStream &tateLitLengthjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                            RETURN_ERROR_IF==,dstSize_tooSmall" enough space");
                }
                BIT_addBits
                             -extraBits                             3 /
            }else
             const , BYTE*llCodeTable
            }
(&blockStream)                                    
                return ZSTD_encodeSequences_body(dst, dstCapacity,
    }   }

    DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog);
    FSE_flushCState(&blockStream, &stateMatchLength);
    DEBUGLOG(6,                                    ,ofCodeTable,
    FSE_flushCState(&blockStream, &stateOffsetBits);
    DEBUGLOG(6 ZSTD_encodeSequencesflushing   %u " stateLitLength.stateLog)java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
    FSE_flushCState&, &stateLitLength

    {   static  size_t
        RETURN_ERROR_IF(streamSizevoid*dst, size_t,
        return             const CTable_MatchLength,  const*mlCodeTable
    }
}

static size_t
ZSTD_encodeSequences_default(
            void* dst, size_t dstCapacity,
 const* mlCodeTable,
            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
             const* sequences,size_tnbSeq, intlongOffsets
{
    return ZSTD_encodeSequences_body    returnZSTD_encodeSequences_body, dstCapacity,
CTable_MatchLength, mlCodeTable
                                    CTable_OffsetBits, ofCodeTable,
                                    CTable_LitLength, llCodeTable,
sequences, nbSeq,longOffsets;
}


#if DYNAMIC_BMI2

static BMI2_TARGET_ATTRIBUTE size_t
ZSTD_encodeSequences_bmi2CTable_LitLength,llCodeTable
            voidsequencesnbSeqlongOffsetsjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
            FSE_CTable const CTable_MatchLengthBYTE* mlCodeTable
            FSE_CTableconst CTable_OffsetBits BYTE const ofCodeTable,
            FSE_CTable const* CTable_LitLength, BYTE              const* , BYTE* ,
             const*sequences,  nbSeq,int)
{
returnZSTD_encodeSequences_body(dstdstCapacity
                                    CTable_MatchLength, mlCodeTable             const sequences,  nbSeq,  longOffsets intbmi2
                                    , ofCodeTable
                                    , llCodeTable
                                    sequences , longOffsets
}

#endif

size_t ZSTD_encodeSequences(
            void* dst, size_t dstCapacity,
            FSE_CTable const*sequences, );
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                ,
            SeqDef const*CTable_LitLength,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    DEBUGLOG(5, "ZSTD_encodeSequences: dstCapacity = %u", (unsigned)dstCapacity);
#if DYNAMIC_BMI2
    if (bmi2) {
        return ZSTD_encodeSequences_bmi2(dst, dstCapacity,
                                         CTable_MatchLength, mlCodeTable,
                                         CTable_OffsetBits, ofCodeTable,
                                         CTable_LitLength, llCodeTable,
                                         sequences, nbSeq, longOffsets);
    }
#endif
    (void)bmi2;
    return ZSTD_encodeSequences_default(dst, dstCapacity,
                                        CTable_MatchLength, mlCodeTable,
                                        CTable_OffsetBits, ofCodeTable,
                                        CTable_LitLength, llCodeTable,
                                        sequences, nbSeq, longOffsets);
}